IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 38986


Ignore:
Timestamp:
Oct 27, 2015, 4:49:06 PM (11 years ago)
Author:
eugene
Message:

extensive work on relphot, relastro, uniphot, dvomerge aiming to the construction and calibration of PV3

Location:
trunk/Ohana
Files:
21 deleted
279 edited
23 copied

Legend:

Unmodified
Added
Removed

  • trunk/Ohana

  • trunk/Ohana/Makefile.Common

    r38441 r38986  
    5151        @echo $<
    5252        @echo $^
     53        echo CFLAGS: $(CFLAGS)
     54        echo TEST_CFLAGS: $(TEST_CFLAGS)
     55        echo BASE_CFLAGS: $(BASE_CFLAGS)
    5356        @if [ ! -d $(TESTDIR) ]; then mkdir -p $(TESTDIR); fi
    5457        $(CC) $(TEST_CFLAGS) -o $@ $^ $(TEST_LDFLAGS)

  • trunk/Ohana/src/addstar/Makefile

    r38636 r38986  
    3737mkcmf        : $(BIN)/mkcmf.$(ARCH)
    3838
    39 # programs in 'OTHERS' have not been updated since moving from Stars to Catalog as an internal carrier
    4039# programs in 'SERVER' use the client-server concept and are out of date
    4140
    42 INSTALL = addstar sedstar loadgalphot loadstarpar loadstarpar_client loadICRF loadICRF_client skycells mkcmf dumpskycells findskycell
    43 OTHERS  = load2mass loadwise loadtycho loadsupercos
     41INSTALL = addstar sedstar loadgalphot loadstarpar loadstarpar_client loadICRF loadICRF_client skycells mkcmf dumpskycells findskycell load2mass loadwise loadtycho loadsupercos
    4442SERVER  = addstar_client addstarc addstard addstart
    4543
    46 old: $(OTHERS)
    4744all: $(INSTALL)
    4845
    4946# I need to fix the client/server version of addstar now that I have dropped Stars
    5047# as an autocode type and have converted to carrying average and measure
    51 # all: addstar sedstar load2mass skycells
    52 
    53 # $(SRC)/find_matches.$(ARCH).o \
    54 # $(SRC)/find_matches_closest.$(ARCH).o \
    55 # $(SRC)/find_matches_refstars.$(ARCH).o \
    56 # $(SRC)/find_matches_closest_refstars.$(ARCH).o \
    57 # $(SRC)/find_subset.$(ARCH).o \
    58 # $(SRC)/getgsc.$(ARCH).o \
    59 # $(SRC)/getusno.$(ARCH).o \
    60 # $(SRC)/getusnob.$(ARCH).o \
    61 # $(SRC)/greference.$(ARCH).o \
    62 # $(SRC)/grefstars.$(ARCH).o \
    63 # $(SRC)/dump.$(ARCH).o \
    64 # $(SRC)/ReadStarsTEXT.$(ARCH).o \
    65 # $(SRC)/StarOps.$(ARCH).o \
    66 # $(SRC)/replace_match.$(ARCH).o \
    67 #
    6848
    6949ADDSTAR = \
    … …  
    10484$(SRC)/ReadStarsUKIRT.$(ARCH).o \
    10585$(SRC)/ReadXradFITS.$(ARCH).o \
     86$(SRC)/find_matches.$(ARCH).o \
     87$(SRC)/find_matches_closest.$(ARCH).o \
     88$(SRC)/find_matches_refstars.$(ARCH).o \
     89$(SRC)/find_matches_closest_refstars.$(ARCH).o \
     90$(SRC)/getgsc.$(ARCH).o \
     91$(SRC)/getusno.$(ARCH).o \
     92$(SRC)/getusnob.$(ARCH).o \
     93$(SRC)/greference.$(ARCH).o \
     94$(SRC)/grefstars.$(ARCH).o \
     95$(SRC)/replace_match.$(ARCH).o \
    10696$(SRC)/FilterStars.$(ARCH).o \
    10797$(SRC)/ImageOptions.$(ARCH).o \
    … …  
    112102$(SRC)/update_coords.$(ARCH).o \
    113103$(SRC)/psps_ids.$(ARCH).o
    114 
    115 ##
    116104
    117105# this is the client for parallel operations
    … …  
    243231$(SRC)/load2mass.$(ARCH).o \
    244232$(SRC)/load2mass_as_rawdata.$(ARCH).o \
    245 $(SRC)/load2mass_catalog.$(ARCH).o \
    246233$(SRC)/get2mass_ops.$(ARCH).o \
    247234$(SRC)/get2mass_full.$(ARCH).o \
    … …  
    252239$(SRC)/update_coords.$(ARCH).o \
    253240$(SRC)/SkyRegionUtils.$(ARCH).o \
    254 $(SRC)/StarOps.$(ARCH).o \
    255 $(SRC)/ConfigInit.$(ARCH).o \
    256 $(SRC)/Shutdown.$(ARCH).o \
    257 $(SRC)/SetSignals.$(ARCH).o \
    258 $(SRC)/psps_ids.$(ARCH).o
     241$(SRC)/ConfigInit.$(ARCH).o \
     242$(SRC)/Shutdown.$(ARCH).o \
     243$(SRC)/SetSignals.$(ARCH).o \
     244$(SRC)/psps_ids.$(ARCH).o
     245
     246# $(SRC)/load2mass_catalog.$(ARCH).o
    259247
    260248LOAD-GALPHOT = \
    … …  
    296284$(SRC)/loadstarpar_save_remote.$(ARCH).o \
    297285$(SRC)/loadstarpar_table.$(ARCH).o \
     286$(SRC)/loadstarpar_extras.$(ARCH).o \
    298287$(SRC)/resort_catalog.$(ARCH).o \
    299288$(SRC)/psps_ids.$(ARCH).o
    … …  
    314303$(SRC)/loadstarpar_save_remote.$(ARCH).o \
    315304$(SRC)/loadstarpar_table.$(ARCH).o \
     305$(SRC)/loadstarpar_extras.$(ARCH).o \
    316306$(SRC)/resort_catalog.$(ARCH).o \
    317307$(SRC)/psps_ids.$(ARCH).o
     308
     309# drop resort_catalog?
    318310
    319311LOAD-ICRF = \
    … …  
    359351$(SRC)/ConfigInit.$(ARCH).o \
    360352$(SRC)/Shutdown.$(ARCH).o \
    361 $(SRC)/StarOps.$(ARCH).o \
    362353$(SRC)/find_matches_refstars.$(ARCH).o \
    363354$(SRC)/build_links.$(ARCH).o \
    … …  
    376367$(SRC)/Shutdown.$(ARCH).o \
    377368$(SRC)/find_matches_closest_refstars.$(ARCH).o \
     369$(SRC)/replace_match.$(ARCH).o \
    378370$(SRC)/build_links.$(ARCH).o \
    379371$(SRC)/SetSignals.$(ARCH).o \
    … …  
    391383$(SRC)/ConfigInit.$(ARCH).o \
    392384$(SRC)/Shutdown.$(ARCH).o \
    393 $(SRC)/StarOps.$(ARCH).o \
     385$(SRC)/SkyListForStars.$(ARCH).o \
    394386$(SRC)/find_matches_refstars.$(ARCH).o \
    395387$(SRC)/build_links.$(ARCH).o \

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

    r24977 r38986  
    2222
    2323SkyTable *get2mass_acc (SkyRegion *patch, char *path, char *accel);
    24 Stars    *get2mass_2DR_data (SkyRegion *region, char *filename, SkyRegion *patch, int photcode, int *nstars);
    25 Stars    *get2mass_AS_data (SkyRegion *region, char *filename, SkyRegion *patch, int phocode, int *nstars);
    26 Stars    *get2mass_AS_rawdata (SkyRegion *region, char *filename, SkyRegion *patch, int phocode, int *nstars);
     24
     25// Stars    *get2mass_2DR_data (SkyRegion *region, char *filename, SkyRegion *patch, int photcode, int *nstars);
     26// Stars    *get2mass_AS_data (SkyRegion *region, char *filename, SkyRegion *patch, int phocode, int *nstars);
     27// Stars    *get2mass_AS_rawdata (SkyRegion *region, char *filename, SkyRegion *patch, int phocode, int *nstars);
    2728
    2829SkyTable *scan2mass_acc (char *path, char *accel);
    … …  
    3536int       load2mass_as_rawdata (SkyList *skytable, char *filename, AddstarClientOptions options);
    3637SkyTable *load2mass_acc (char *path, char *accel);
    37 int       get2mass_3star (Stars *star, char *line, int Nmax);
    38 int       load2mass_catalog (Catalog *catalog, Stars *stars, int Nstars);
     38
     39// int       get2mass_3star (Stars *star, char *line, int Nmax);
     40// int       load2mass_catalog (Catalog *catalog, Stars *stars, int Nstars);
    3941
    4042int       get2mass_setup (int photcode);
    4143int       get2mass_coords (char *line, double *R, double *D, int Nmax);
    42 int       get2mass_star (Stars *star, char *line, int Nmax);
    43 int       get2mass_3star (Stars *star, char *line, int Nmax);
    4444
    45 int get2mass_3star_full (Stars **star, char *line, int Nmax);
     45// int       get2mass_star (Stars *star, char *line, int Nmax);
     46// int       get2mass_3star (Stars *star, char *line, int Nmax);
     47
     48int get2mass_3star_full (Measure *measure, char *line, int Nmax);
    4649char *next2MASSfield (char *line);
    47 int set2MASS_ph_qual (Stars *star, char qual);
    48 int set2MASS_rd_flag (Stars *star, char qual);
    49 int set2MASS_cc_flag (Stars *star, char qual);
    50 int set2MASS_bl_flag (Stars *star, char qual);
    51 int set2MASS_gal_flag (Stars *star, char qual);
    52 int set2MASS_mp_flag (Stars *star, char qual);
    53 int set2MASS_dup_flag (Stars *star, char qual);
    54 int set2MASS_use_flag (Stars *star, char qual);
     50int set2MASS_ph_qual (Measure *measure, char qual);
     51int set2MASS_rd_flag (Measure *measure, char qual);
     52int set2MASS_cc_flag (Measure *measure, char qual);
     53int set2MASS_bl_flag (Measure *measure, char qual);
     54int set2MASS_gal_flag (Measure *measure, char qual);
     55int set2MASS_mp_flag (Measure *measure, char qual);
     56int set2MASS_dup_flag (Measure *measure, char qual);
     57int set2MASS_use_flag (Measure *measure, char qual);
    5558int get2mass_sortStars (TMStars *tstars, int Ntstars);

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

    r38062 r38986  
    3535int getWISE_sortStars (WISE_Stars *tstars, int Ntstars);
    3636
    37 int loadwise_star_prelim (Stars **star, char *line, int Nmax);
    38 int loadwise_star_allsky (Stars **star, char *line, int Nmax);
    39 int loadwise_star_allwise (Stars **star, char *line, int Nmax);
     37int loadwise_star_prelim  (Measure *measure, char *line, int Nmax);
     38int loadwise_star_allsky  (Measure *measure, char *line, int Nmax);
     39int loadwise_star_allwise (Measure *measure, char *line, int Nmax);
    4040
    4141
    4242char *nextWISEfield (char *line);
    43 int setWISE_cc_flag (Stars *star, char qual);
    44 int setWISE_ph_qual (Stars *star, char qual);
    45 int setWISE_rd_flag (Stars *star, char qual);
    46 int setWISE_bl_flag (Stars *star, char qual);
    47 int setWISE_gal_flag (Stars *star, char qual);
    48 int setWISE_mp_flag (Stars *star, char qual);
    49 int setWISE_dup_flag (Stars *star, char qual);
    50 int setWISE_use_flag (Stars *star, char qual);
     43int setWISE_cc_flag  (Measure *measure, char qual);
     44int setWISE_ph_qual  (Measure *measure, char qual);
     45int setWISE_rd_flag  (Measure *measure, char qual);
     46int setWISE_bl_flag  (Measure *measure, char qual);
     47int setWISE_gal_flag (Measure *measure, char qual);
     48int setWISE_mp_flag  (Measure *measure, char qual);
     49int setWISE_dup_flag (Measure *measure, char qual);
     50int setWISE_use_flag (Measure *measure, char qual);
    5151
    5252char *skipNbounds (char *line, char bound, int Nbound, int Nbyte);

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

    r38636 r38986  
    4949  int extnum_xrad;
    5050} HeaderSet;
    51 
    52 # if (0)
    53 typedef struct {
    54   Average  average;
    55   Measure  measure;
    56   Lensing *lensing; // optionally carry out the lensing measurements
    57   int found;
    58 } Stars;
    59 
    60 typedef struct {
    61   unsigned int Nstars;
    62   Stars *stars;
    63   off_t Nimages;
    64   Image *images;
    65   Coords *mosaic;
    66   SkyRegion *patch;
    67   AddstarClientOptions *options;
    68   char *refcat;
    69 } DVO_DATA;
    70 # endif
    7151
    7252# define IDTYPE int
    … …  
    222202int        find_matches           PROTO((SkyRegion *region, Catalog *newcat, Catalog *catalog, AddstarClientOptions options));
    223203
    224 # if (0)
    225 int        find_matches_refstars         PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
    226 int        find_matches_closest_refstars PROTO((SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options));
    227 
    228 int        dump_rawstars          PROTO((Stars *stars, unsigned int Nstars));
    229 
    230 Stars    **find_subset            PROTO((SkyRegion *region, Stars *stars, unsigned int Nstars, unsigned int *NSTARS));
     204int        find_matches_refstars         PROTO((SkyRegion *region, Catalog *srccat, Catalog *tgtcat, AddstarClientOptions options));
     205int        find_matches_closest_refstars PROTO((SkyRegion *region, Catalog *srccat, Catalog *tgtcat, AddstarClientOptions options));
     206
     207Catalog   *greference             PROTO((char *Refcat, SkyRegion *catstats, int photcode));
     208
    231209int        gcatalog               PROTO((Catalog *catalog));
    232 Stars     *get2mass               PROTO((SkyRegion *patch, int photcode, int mode, unsigned int *NSTARS));
    233 
    234 Stars     *greference             PROTO((char *Refcat, SkyRegion *catstats, int photcode, unsigned int *nstars));
    235 Stars     *getgsc                 PROTO((SkyRegion *patch, unsigned int *NSTARS));
    236 Stars     *getusno                PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
    237 Stars     *getusnob               PROTO((SkyRegion *catstats, int photcode, unsigned int *Nstars));
     210Catalog   *getgsc                 PROTO((SkyRegion *patch));
     211Catalog   *getusno                PROTO((SkyRegion *catstats));
     212Catalog   *getusnob               PROTO((SkyRegion *catstats));
    238213
    239214// load text-based stars (REF only in the sense of REF photcodes)
    240 Stars     *grefstars              PROTO((char *file, int photcode, unsigned int *Nstars));
    241 
    242 Stars     *rd_gsc                 PROTO((char *filename, unsigned int *nstars));
    243 
    244 int        replace_match          PROTO((Average *average, Measure *measure, Stars *star));
    245 # endif
     215Catalog   *grefstars              PROTO((char *file, int photcode));
     216
     217Catalog   *rd_gsc                 PROTO((char *filename));
     218
     219int        replace_match          PROTO((Average *average, Measure *measure, Measure *newmeas, off_t *found));
    246220
    247221Catalog   *LoadStars              PROTO((char *file, Image **images, off_t *Nimages, AddstarClientOptions *options));
    … …  
    297271
    298272SkyList   *SkyListExistingSubset  PROTO((SkyList *input, char *path));
     273SkyList   *SkyListForStars        PROTO((SkyTable *table, int depth, Catalog *catalog));
    299274
    300275// these are all for the addstar client/server which has not been maintained
    … …  
    311286int        UpdateDatabase_Reflist PROTO((AddstarClientOptions *options, Stars *stars, unsigned int Nstars));
    312287int        UpdateDatabase_Refcat  PROTO((AddstarClientOptions *options, SkyRegion *UserPatch, char *refcat));
    313 SkyList   *SkyListForStars        PROTO((SkyTable *table, int depth, Stars *stars, unsigned int Nstars));
    314288int        SkyListSetPath         PROTO((SkyList *list, char *path));
    315289int        InitDataset            PROTO((void));

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

    r37807 r38986  
    1212char *INPUT;
    1313
    14 AddstarClientOptions args_loadstarpar (int argc, char **argv, AddstarClientOptions options);
    15 AddstarClientOptions args_loadstarpar_client (int argc, char **argv, AddstarClientOptions options);
     14AddstarClientOptions args_loadstarpar (int *argc, char **argv, AddstarClientOptions options);
     15AddstarClientOptions args_loadstarpar_client (int *argc, char **argv, AddstarClientOptions options);
    1616
    1717int loadstarpar_table (SkyList *skylistInput, HostTable *hosts, char *filename, AddstarClientOptions *options);
    … …  
    2323int save_remote_host (HostInfo *host);
    2424
    25 int init_remote_hosts ();
    26 int find_empty_slot ();
    27 int harvest_all ();
    28 int harvest_host ();
     25int init_remote_hosts (void);
     26int find_empty_slot (void);
     27int harvest_all (void);
     28int harvest_host (void);
    2929
    3030int loadstarpar_catalog (StarPar_Stars *stars, int Nstars, SkyRegion *region, char *filename, AddstarClientOptions *options);
    … …  
    4040
    4141int loadstarpar_sortStars (StarPar_Stars *stars, int Nstars);
     42
     43int loadstarpar_tmpdir (void);

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

    r33653 r38986  
    8080Image *loadsupercos_plates (Survey *survey, int Nsurvey, char *filename, int *nimage);
    8181int loadsupercos_getFilterInfo (char *line, char *emulsion, char *filterID);
    82 int loadsupercos_rawdata (Image *image, int *imlist, int Nimage, SkyList *skytable, char *filename, AddstarClientOptions options);
    83 int loadsupercos_sortStars (Stars *tstars, int Ntstars);
     82int loadsupercos_rawdata (Image *image, int *imlist, int Nimage, SkyTable *skytable, char *filename, AddstarClientOptions options);
    8483int *loadsupercos_image_index (Image *image, int Nimage);
    8584int loadsupercos_getST (char *line, double *st);

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

    • Property svn:mergeinfo deleted

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

    r38553 r38986  
    11# include "addstar.h"
    22
    3 # if (0)
    4 void sort_stars_ra (Stars *stars, int N) {
     3void sort_stars_ra (Catalog *catalog) {
    54
    6 # define SWAPFUNC(A,B){ Stars tmp; tmp = stars[A]; stars[A] = stars[B]; stars[B] = tmp; }
    7 # define COMPARE(A,B)(stars[A].average.R < stars[B].average.R)
     5# define SWAPFUNC(A,B){ Average tmp; tmp = catalog->average[A]; catalog->average[A] = catalog->average[B]; catalog->average[B] = tmp; }
     6# define COMPARE(A,B)(catalog->average[A].R < catalog->average[B].R)
    87
    9   OHANA_SORT (N, COMPARE, SWAPFUNC);
     8  OHANA_SORT (catalog->Naverage, COMPARE, SWAPFUNC);
    109
    1110# undef SWAPFUNC
    … …  
    1413}
    1514
    16 SkyList *SkyListForStars (SkyTable *table, int depth, Stars *stars, unsigned int Nstars) {
     15SkyList *SkyListForStars (SkyTable *table, int depth, Catalog *catalog) {
    1716 
    1817  int i, j, Nr, NR;
    … …  
    2827  list[0].ownElements = FALSE; // free these elements when freeing the list
    2928
    30   sort_stars_ra (stars, Nstars); /* sort by RA */
    31   for (i = 0; i < Nstars; i++) {
    32     if (stars[i].found == -2) continue;
    33     here = SkyRegionByPoint (table, depth, stars[i].average.R, stars[i].average.D);
    34     stars[i].found = -2;
     29  sort_stars_ra (catalog); /* sort by RA */
     30
     31  ALLOCATE (catalog->found_t, off_t, catalog->Naverage);
     32  for (i = 0; i < catalog->Naverage; i++) {
     33    catalog->found_t[i] = 0;
     34  }
     35
     36  for (i = 0; i < catalog->Naverage; i++) {
     37    if (catalog->found_t[i] == -2) continue;
     38    here = SkyRegionByPoint (table, depth, catalog->average[i].R, catalog->average[i].D);
     39    catalog->found_t[i] = -2;
    3540    /* search forward for all contained stars */
    36     for (j = i; j < Nstars; j++) {
    37       if (stars[j].average.R >= here[0].regions[0][0].Rmax) break;
    38       if (stars[j].average.R <  here[0].regions[0][0].Rmin) break;
    39       if (stars[j].average.D <  here[0].regions[0][0].Dmin) continue;
    40       if (stars[j].average.D >= here[0].regions[0][0].Dmax) continue;
    41       stars[j].found = -2;
     41    for (j = i; j < catalog->Naverage; j++) {
     42      if (catalog->average[j].R >= here[0].regions[0][0].Rmax) break;
     43      if (catalog->average[j].R <  here[0].regions[0][0].Rmin) break;
     44      if (catalog->average[j].D <  here[0].regions[0][0].Dmin) continue;
     45      if (catalog->average[j].D >= here[0].regions[0][0].Dmax) continue;
     46      catalog->found_t[j] = -2;
    4247    }
    4348    list[0].regions[Nr] = here[0].regions[0];
    … …  
    5459
    5560  /* reset to -1 for all stars: required start for find_match_refstars */
    56   for (i = 0; i < Nstars; i++) stars[i].found = -1;
     61  free (catalog->found_t);
     62  catalog->found_t = NULL;
    5763  return (list);
    5864}
    … …  
    7076
    7177*/
    72 # endif

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

    r38471 r38986  
    7979        dvo_catalog_save (&catalog, VERBOSE);
    8080      }
    81       SetProtect (FALSE);
    8281    }
    8382    dvo_catalog_unlock (&catalog);
     83    SetProtect (FALSE);
     84
    8485    dvo_catalog_free (&catalog);
    8586  }

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

    r38471 r38986  
    6969        dvo_catalog_save (&catalog, VERBOSE);
    7070      }
    71       SetProtect (FALSE);
    7271    }
    7372    dvo_catalog_unlock (&catalog);
     73    SetProtect (FALSE);
     74
    7475    dvo_catalog_free (&catalog);
    7576    free (stars);

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

    r38471 r38986  
    6565        dvo_catalog_save (&catalog, VERBOSE);
    6666      }
    67       SetProtect (FALSE);
    6867    }
    6968    dvo_catalog_unlock (&catalog);
     69    SetProtect (FALSE);
     70
    7071    dvo_catalog_free (&catalog);
    7172  }

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

    r38553 r38986  
    5757      UpdateImageIDs (newcat, images, Nimages);
    5858
    59       // if ((DUMP != NULL) && !strcmp (DUMP, "rawstars")) dump_rawstars (stars, Nstars);
    6059      for (i = 0; i < Nimages; i++) {
    6160        newlist = SkyListByImage (sky, -1, &images[i]);
    … …  
    6665      ImageOptions (&options, images, Nimages);
    6766      break;
    68 # if (0)
    6967    case ADDSTAR_MODE_REFLIST:
    70       stars = grefstars (argv[1], options.photcode, &Nstars);
    71       skylist = SkyListForStars (sky, -1, stars, Nstars);
     68      newcat = grefstars (argv[1], options.photcode);
     69      skylist = SkyListForStars (sky, -1, newcat);
    7270      break;
    7371    case ADDSTAR_MODE_REFCAT:
    … …  
    8078      skylist[0].ownElements = FALSE;
    8179      break;
    82 # endif
    8380
    8481    default:
    … …  
    146143    switch (options.mode) {
    147144      case ADDSTAR_MODE_IMAGE:
    148         // Nsubset = Nstars;
    149145        if (options.closest) {
    150146          Nmatch += find_matches_closest (skylist[0].regions[i], newcat, &catalog, options);
    … …  
    153149        }
    154150        break;
    155 # if (0)
     151
    156152      case ADDSTAR_MODE_REFCAT:
    157         stars = greference (argv[1], skylist[0].regions[i], options.photcode, &Nstars);
     153        newcat = greference (argv[1], skylist[0].regions[i], options.photcode);
    158154      case ADDSTAR_MODE_REFLIST: {
    159         Stars **subset = find_subset (skylist[0].regions[i], stars, Nstars, &Nsubset);
    160155        if (options.closest) {
    161           Nmatch += find_matches_closest_refstars (skylist[0].regions[i], subset, Nsubset, &catalog, options);
     156          Nmatch += find_matches_closest_refstars (skylist[0].regions[i], newcat, &catalog, options);
    162157        } else {
    163           Nmatch += find_matches_refstars (skylist[0].regions[i], subset, Nsubset, &catalog, options);
     158          Nmatch += find_matches_refstars (skylist[0].regions[i], newcat, &catalog, options);
    164159        }
    165         if (Nsubset) free (subset);
    166160        break;
    167161      }
    168 # endif
    169162      default:
    170163        abort();
    … …  
    186179        dvo_catalog_save (&catalog, VERBOSE);
    187180      }
    188       SetProtect (FALSE);
    189181    }
    190182    dvo_catalog_unlock (&catalog);
     183    SetProtect (FALSE);
    191184    dvo_catalog_free (&catalog);
    192185    if (VERBOSE) MARKTIME ("save cpt: %f sec\n", dtime); RESETTIME;

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

    r37116 r38986  
    1313
    1414  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, etc)
     15  SetSignals ();
    1516  options = ConfigInit (&argc, argv);
    1617  options = args_parallel_client (argc, argv, options);

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

    r33963 r38986  
    1111
    1212  /* load config and options */
     13  SetSignals ();
    1314  options = ConfigInit (&argc, argv);
    1415  options = args_client (argc, argv, options);

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

    r27435 r38986  
    88  AddstarClientOptions options;
    99
     10  SetSignals ();
    1011  options = ConfigInit (&argc, argv);
    1112  args_server (argc, argv);

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

    r33963 r38986  
    88  DVO_DATA *dataset;
    99
     10  SetSignals ();
    1011  options = ConfigInit (&argc, argv);
    1112  args_server (argc, argv);

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

    r37807 r38986  
    55static void help_client (void);
    66
    7 AddstarClientOptions args_loadstarpar (int argc, char **argv, AddstarClientOptions options) {
     7AddstarClientOptions args_loadstarpar (int *argc, char **argv, AddstarClientOptions options) {
    88 
    99  int N;
    1010
    1111  /* check for help request */
    12   if (get_argument (argc, argv, "-help") ||
    13       get_argument (argc, argv, "-h")) {
     12  if (get_argument (*argc, argv, "-help") ||
     13      get_argument (*argc, argv, "-h")) {
    1414    help ();
    1515  }
    … …  
    2828  HOST_ID = 0;
    2929  PARALLEL = FALSE;
    30   if ((N = get_argument (argc, argv, "-parallel"))) {
     30  if ((N = get_argument (*argc, argv, "-parallel"))) {
    3131    PARALLEL = TRUE;
    32     remove_argument (N, &argc, argv);
     32    remove_argument (N, argc, argv);
    3333  }
    3434  // this is a test mode : rather than launching the remote jobs and waiting for completion,
    3535  // relphot will simply list the remote command and wait for the user to signal completion
    3636  PARALLEL_MANUAL = FALSE;
    37   if ((N = get_argument (argc, argv, "-parallel-manual"))) {
     37  if ((N = get_argument (*argc, argv, "-parallel-manual"))) {
    3838    PARALLEL = TRUE; // -parallel-manual implies -parallel
    3939    PARALLEL_MANUAL = TRUE;
    40     remove_argument (N, &argc, argv);
     40    remove_argument (N, argc, argv);
    4141  }
    4242  // this is a test mode : rather than launching the relphot_client jobs remotely, they are
    4343  // run in serial via 'system'
    4444  PARALLEL_SERIAL = FALSE;
    45   if ((N = get_argument (argc, argv, "-parallel-serial"))) {
     45  if ((N = get_argument (*argc, argv, "-parallel-serial"))) {
    4646    if (PARALLEL_MANUAL) {
    4747      fprintf (stderr, "ERROR: cannot mix -parallel-manual and -parallel-serial\n");
    … …  
    5050    PARALLEL = TRUE; // -parallel-serial implies -parallel
    5151    PARALLEL_SERIAL = TRUE;
    52     remove_argument (N, &argc, argv);
    53   }
    54 
    55   /* only add to existing regions */
     52    remove_argument (N, argc, argv);
     53  }
     54
     55  /* only add to existing regions  */
    5656  options.existing_regions = FALSE;
    57   if ((N = get_argument (argc, argv, "-existing-regions"))) {
    58     options.existing_regions = TRUE;
    59     remove_argument (N, &argc, argv);
    60   }
     57  // XXX NOT USED if ((N = get_argument (*argc, argv, "-existing-regions"))) {
     58  // XXX NOT USED   options.existing_regions = TRUE;
     59  // XXX NOT USED   remove_argument (N, argc, argv);
     60  // XXX NOT USED }
     61
    6162  /* only add to existing objects */
    6263  options.only_match = FALSE;
    63   if ((N = get_argument (argc, argv, "-only-match"))) {
     64  if ((N = get_argument (*argc, argv, "-only-match"))) {
    6465    options.only_match = TRUE;
    65     remove_argument (N, &argc, argv);
    66   }
     66    remove_argument (N, argc, argv);
     67  }
     68
    6769  /* replace measurement, don't duplicate (ref/cat only) */
    6870  options.replace = FALSE;
    69   if ((N = get_argument (argc, argv, "-replace"))) {
     71  if ((N = get_argument (*argc, argv, "-replace"))) {
    7072    options.replace = TRUE;
    71     remove_argument (N, &argc, argv);
     73    remove_argument (N, argc, argv);
    7274  }
    7375
    7476  /* extra error messages */
    7577  VERBOSE = FALSE;
    76   if ((N = get_argument (argc, argv, "-v"))) {
     78  if ((N = get_argument (*argc, argv, "-v"))) {
    7779    VERBOSE = TRUE;
    78     remove_argument (N, &argc, argv);
     80    remove_argument (N, argc, argv);
    7981  }
    8082
    … …  
    9698  DUMP = NULL;
    9799
    98   if (argc < 2) {
     100  if (*argc < 2) {
    99101    fprintf (stderr, "USAGE: loadstarpar [options] (fitsfile) [..more files]\n");
    100102    exit (2);
    … …  
    103105}
    104106
    105 AddstarClientOptions args_loadstarpar_client (int argc, char **argv, AddstarClientOptions options) {
     107AddstarClientOptions args_loadstarpar_client (int *argc, char **argv, AddstarClientOptions options) {
    106108 
    107109  int N;
    108110
    109111  /* check for help request */
    110   if (get_argument (argc, argv, "-help") ||
    111       get_argument (argc, argv, "-h")) {
     112  if (get_argument (*argc, argv, "-help") ||
     113      get_argument (*argc, argv, "-h")) {
    112114    help ();
    113115  }
    … …  
    118120
    119121  HOST_ID = 0;
    120   if ((N = get_argument (argc, argv, "-hostID"))) {
    121     remove_argument (N, &argc, argv);
     122  if ((N = get_argument (*argc, argv, "-hostID"))) {
     123    remove_argument (N, argc, argv);
    122124    HOST_ID = atoi (argv[N]);
    123     remove_argument (N, &argc, argv);
     125    remove_argument (N, argc, argv);
    124126  }
    125127  if (!HOST_ID) help_client();
    126128
    127129  HOSTDIR = NULL;
    128   if ((N = get_argument (argc, argv, "-hostdir"))) {
    129     remove_argument (N, &argc, argv);
     130  if ((N = get_argument (*argc, argv, "-hostdir"))) {
     131    remove_argument (N, argc, argv);
    130132    HOSTDIR = strcreate (argv[N]);
    131     remove_argument (N, &argc, argv);
     133    remove_argument (N, argc, argv);
    132134  }
    133135  if (!HOSTDIR) help_client();
    134136
    135137  CPT_FILE = NULL;
    136   if ((N = get_argument (argc, argv, "-cpt"))) {
    137     remove_argument (N, &argc, argv);
     138  if ((N = get_argument (*argc, argv, "-cpt"))) {
     139    remove_argument (N, argc, argv);
    138140    CPT_FILE = strcreate (argv[N]);
    139     remove_argument (N, &argc, argv);
     141    remove_argument (N, argc, argv);
    140142  }
    141143  if (!CPT_FILE) help_client();
    142144 
    143145  INPUT = NULL;
    144   if ((N = get_argument (argc, argv, "-input"))) {
    145     remove_argument (N, &argc, argv);
     146  if ((N = get_argument (*argc, argv, "-input"))) {
     147    remove_argument (N, argc, argv);
    146148    INPUT = strcreate (argv[N]);
    147     remove_argument (N, &argc, argv);
     149    remove_argument (N, argc, argv);
    148150  }
    149151  if (!INPUT) help_client();
    … …  
    157159  /* only add to existing objects */
    158160  options.only_match = FALSE;
    159   if ((N = get_argument (argc, argv, "-only-match"))) {
     161  if ((N = get_argument (*argc, argv, "-only-match"))) {
    160162    options.only_match = TRUE;
    161     remove_argument (N, &argc, argv);
     163    remove_argument (N, argc, argv);
    162164  }
    163165  /* replace measurement, don't duplicate (ref/cat only) */
    164166  options.replace = FALSE;
    165   if ((N = get_argument (argc, argv, "-replace"))) {
     167  if ((N = get_argument (*argc, argv, "-replace"))) {
    166168    options.replace = TRUE;
    167     remove_argument (N, &argc, argv);
     169    remove_argument (N, argc, argv);
    168170  }
    169171
    170172  /* extra error messages */
    171173  VERBOSE = FALSE;
    172   if ((N = get_argument (argc, argv, "-v"))) {
     174  if ((N = get_argument (*argc, argv, "-v"))) {
    173175    VERBOSE = TRUE;
    174     remove_argument (N, &argc, argv);
     176    remove_argument (N, argc, argv);
    175177  }
    176178
    … …  
    192194  DUMP = NULL;
    193195
    194   if (argc != 1) {
     196  if (*argc != 1) {
    195197    fprintf (stderr, "USAGE: loadstarpar_client -cpt (file) -input (file)\n");
    196198    exit (2);

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

    r38553 r38986  
    33int find_matches (SkyRegion *region, Catalog *srccat, Catalog *tgtcat, AddstarClientOptions options) {
    44
    5   off_t i, j, n, N, J, Nstars, mSrc;
     5  off_t i, j, J, Nstars, mSrc;
    66  double RADIUS, RADIUS2;
    77  double *X1, *Y1, *X2, *Y2;
    … …  
    99  off_t *N1, *N2;
    1010  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    11   int Nsecfilt, Nsec, status;
    1211  unsigned int objID, catID;
    1312  Coords tcoords;
     13  int Nsecfilt, Nsec;
    1414
    1515  /* photcode data - must by of type DEP; options.photcode is equiv photcode for all input
    … …  
    5858  catID = tgtcat[0].catID;
    5959
    60   /* project onto rectilinear grid with 1 arcsec pixels. the choice of ZEA projection has the
    61    * advantage that every point in R,D has a mapping to a unique X,Y.  However, note that not all
    62    * possible X,Y points map back to R,D and the local plate scale changes substantially far from
    63    * the projection pole.  a better mapping might be ARC, not yet implemented (see
    64    * coordops.update.c).  We use the center of the region (tgtcat) for crval1,2.
     60  /* project onto rectilinear grid with 1 arcsec pixels. the choice of ARC projection has
     61   * the advantage that every point in R,D has a mapping to a unique X,Y.  However, note
     62   * that not all possible X,Y points map back to R,D and the local plate scale changes
     63   * substantially far from the projection pole.  We use the center of the region (tgtcat)
     64   * for crval1,2.
    6565   */
    6666  InitCoords (&tcoords, "DEC--ARC");
    6767  tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
    68   if (region[0].Dmax < 90) {
     68  if ((region[0].Dmax < 90) && (region[0].Dmin > -90)) {
    6969    tcoords.crval2 = 0.5*(region[0].Dmin + region[0].Dmax);
    7070  } else {
    71     tcoords.crval2 = 90.0;
     71    tcoords.crval2 = (region[0].Dmax >= 90) ? 90.0 : -90.0;
    7272  }
    7373  tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
    … …  
    7676  Nstars = 0;
    7777  for (i = 0; i < srccat->Naverage; i++) {
    78     status = RD_to_XY (&X1[Nstars], &Y1[Nstars], srccat->average[i].R, srccat->average[i].D, &tcoords);
     78    int status = RD_to_XY (&X1[Nstars], &Y1[Nstars], srccat->average[i].R, srccat->average[i].D, &tcoords);
    7979    if (!status) continue;
    8080    N1[Nstars] = i;
    … …  
    101101  if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave);
    102102
    103   /* set up pointers for linked list of measure */
     103  /* set up pointers for linked list of measurements */
    104104  if (tgtcat[0].sorted && (tgtcat[0].Nmeasure == tgtcat[0].Nmeasure_disk)) {
     105    // this version is only valid if we have done a full catalog load, and if the catalog
     106    // is sorted while processed
    105107    next_meas = init_measure_links (tgtcat[0].average, Nave, tgtcat[0].measure, Nmeas);
    106108  } else {
    … …  
    109111
    110112  /* choose a radius for matches (defined in args.c or ImageOptions.c) */
    111   RADIUS = options.radius;
     113  if (options.radius == 0) {
     114    RADIUS = 2.0; /* hardwired default for refstars */
     115  } else {
     116    RADIUS = options.radius; /* provided by config */
     117  }
    112118  RADIUS2 = RADIUS*RADIUS;
    113119
    114   /** find matched stars **/
     120  /****************** find matched stars ********************/
     121
    115122  for (i = j = 0; (i < Nstars) && (j < Nave); ) {
    116123    if (!finite(X1[i]) || !finite(Y1[i])) {
    … …  
    144151      /*** a match is found, add to average, measure ***/
    145152      Nmatch ++;
    146       n = N2[J];
    147       N = N1[i];
     153      off_t n = N2[J];
     154      off_t N = N1[i];
    148155
    149156      /* make sure there is space for next entry */
    … …  
    161168       
    162169        /** add measurements for this star **/
    163        
     170
    164171        // set the new measurements
    165172        tgtcat[0].measure[Nmeas]          = srccat->measure[mSrc + mOff];
    … …  
    231238          tgtcat[0].found_t[n] = Nmeas;
    232239        }
    233         /* Nm is updated, but not written out in -update mode (for existing entries)
    234            Nm is recalculated in build_meas_links if loaded table is not sorted */
    235240        tgtcat[0].average[n].Nmeasure ++;
    236241        Nmeas ++;
    … …  
    245250  }
    246251
    247 /* incorporate unmatched image stars, if this star is in field of this tgtcat */
    248 /* these new entries are all written out in UPDATE mode */
    249   for (i = 0; (i < Nstars) && !options.only_match; i ++) {
     252  /* incorporate unmatched image stars, if this star is in field of this tgtcat */
     253  /* these new entries are all written out in UPDATE mode */
     254  for (i = 0; (i < Nstars) && !options.only_match; i++) {
    250255    /* make sure there is space for next entry */
    251256    if (Nmeas >= NMEAS - srccat->average[i].Nmeasure) {
    … …  
    324329  }
    325330
    326 /* note stars which have been found in this tgtcat */
     331  /* note stars which have been found in this tgtcat */
    327332  for (i = 0; i < srccat->Nmeasure; i++) {
    328333    if (srccat->found_t[i] > -1) {
    … …  
    331336  }
    332337
    333 /* check if the tgtcat has changed?  if no change, no need to write */
     338  /* check if the tgtcat has changed?  if no change, no need to write */
    334339  tgtcat[0].objID    = objID; // new max value, save on tgtcat close
    335340  tgtcat[0].Naverage = Nave;
    … …  
    341346  free (Y1);
    342347  free (N1);
    343   free (N2);
    344348  free (X2);
    345349  free (Y2);
     350  free (N2);
    346351  free (next_meas);
    347352

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

    r38553 r38986  
    33int find_matches_closest (SkyRegion *region, Catalog *srccat, Catalog *tgtcat, AddstarClientOptions options) {
    44
    5   off_t i, j, n, N, J, Jmin, status, Nstars, mSrc;
     5  off_t i, j, J, Jmin, status, Nstars, mSrc;
    66  double RADIUS, RADIUS2, Rmin;
    77  double *X1, *Y1, *X2, *Y2;
    … …  
    99  off_t *N1, *N2;
    1010  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch, Nlens, NLENS;
    11   int Nsecfilt, Nsec;
    1211  unsigned int objID, catID;
    1312  Coords tcoords;
     13  int Nsecfilt, Nsec;
    1414
    1515  /* photcode data - must by of type DEP; options.photcode is equiv photcode for all input
    … …  
    6262   * the advantage that every point in R,D has a mapping to a unique X,Y.  However, note
    6363   * that not all possible X,Y points map back to R,D and the local plate scale changes
    64    * far from the projection pole. We use the center of the region (tgtcat) for crval1,2.
     64   * substantially far from the projection pole. We use the center of the region (tgtcat)
     65   * for crval1,2.
    6566   */
    6667  InitCoords (&tcoords, "DEC--ARC");
    6768  tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
    68   if (region[0].Dmax < 90) {
     69  if ((region[0].Dmax < 90) && (region[0].Dmin > -90)) {
    6970    tcoords.crval2 = 0.5*(region[0].Dmin + region[0].Dmax);
    7071  } else {
    71     tcoords.crval2 = 90.0;
     72    tcoords.crval2 = (region[0].Dmax >= 90) ? 90.0 : -90.0;
    7273  }
    7374  tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
    … …  
    114115
    115116  /* choose a radius for matches */
    116   RADIUS = options.radius; /* provided by config */
     117  if (options.radius == 0) {
     118    RADIUS = 2.0; /* hardwired default for refstars */
     119  } else {
     120    RADIUS = options.radius; /* provided by config */
     121  }
    117122  RADIUS2 = RADIUS*RADIUS;
    118123
    … …  
    178183    /*** a match is found, add to average, measure ***/
    179184    Nmatch ++;
    180     n = N2[Jmin];
    181     N = N1[i];
     185    off_t n = N2[Jmin];
     186    off_t N = N1[i];
    182187
    183188    /* make sure there is space for next entry */
    … …  
    355360      next_meas[Nmeas-1] = (mSrc < srccat->average[i].Nmeasure - 1) ? Nmeas : -1;
    356361    }
    357     srccat->found_t[i] = Nave;
    358 
    359362    // if we have lensing data, insert that as well
    360363    if (srccat->lensing) {
    … …  
    374377      }
    375378    }
     379    srccat->found_t[i] = Nave;
    376380    Nave ++;
    377381  }
    … …  
    407411  free (Y1);
    408412  free (N1);
    409   free (N2);
    410413  free (X2);
    411414  free (Y2);
     415  free (N2);
    412416  free (next_meas);
    413417  free (next_lens);

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

    r38467 r38986  
    11# include "addstar.h"
    22
    3 /* differences with find_matches_closest():
    4  * accepts Stars **stars (vs Stars *stars)
    5  * NREFSTAR_GROUP vs NSTAR_GROUP
    6  * does not update lensing fields
    7  * allows option to replace existing entries
    8  * allows multiple photcodes
    9 
    10  */
    11 
    12 int find_matches_closest_refstars (SkyRegion *region, Stars **stars, unsigned int NstarsIn, Catalog *catalog, AddstarClientOptions options) {
    13 
    14   off_t i, j, n, N, J, Jmin, status;
     3int find_matches_closest_refstars (SkyRegion *region, Catalog *srccat, Catalog *tgtcat, AddstarClientOptions options) {
     4
     5  off_t i, j, J, Jmin, status, mSrc;
    156  double RADIUS, RADIUS2, Rmin;
    167  double *X1, *Y1, *X2, *Y2;
    178  double dX, dY, dR;
    18   off_t *N1, *N2, *next_meas;
     9  off_t *N1, *N2;
    1910  off_t Nave, NAVE, Nmeas, NMEAS, Nstars, Nmatch;
    2011  unsigned int objID, catID;
    … …  
    2213  int Nsecfilt;
    2314
    24   switch (NREFSTAR_GROUP) {
    25     case 1:
    26     case 3:
    27     case 4:
    28     case 6:
    29       break;
    30     default:
    31       fprintf (stderr, "ERROR: NREFSTAR_GROUP NOT SET!\n");
    32       exit (1);
    33   }
    34 
    3515  /* photcode data -- should not have to modify secfilt / average */
    3616  Nsecfilt = GetPhotcodeNsecfilt ();
    3717
    38   /** allocate local arrays (stars) **/
    39   ALLOCATE (X1, double, NstarsIn);
    40   ALLOCATE (Y1, double, NstarsIn);
    41   ALLOCATE (N1, off_t,  NstarsIn);
    42 
    43   /** allocate local arrays (catalog) **/
    44   NAVE = Nave = catalog[0].Naverage;
     18  /** allocate local arrays (srccat) **/
     19  ALLOCATE (X1, double, srccat->Naverage);
     20  ALLOCATE (Y1, double, srccat->Naverage);
     21  ALLOCATE (N1, off_t,  srccat->Naverage);
     22
     23  if (!srccat->found_t) {
     24    ALLOCATE (srccat->found_t, off_t, srccat->Naverage);
     25    for (i = 0; i < srccat->Naverage; i++) {
     26      srccat->found_t[i] = -1;
     27    }
     28  }
     29
     30  /** allocate local arrays (tgtcat) **/
     31  NAVE = Nave = tgtcat[0].Naverage;
    4532  ALLOCATE (X2, double, NAVE);
    4633  ALLOCATE (Y2, double, NAVE);
    4734  ALLOCATE (N2, off_t,  NAVE);
    48   ALLOCATE (catalog[0].found_t, off_t, NAVE);
     35
     36  if (!tgtcat->found_t) {
     37    ALLOCATE (tgtcat[0].found_t, off_t, NAVE);
     38    for (i = 0; i < NAVE; i++) {
     39      tgtcat->found_t[i] = -1;
     40    }
     41  }
    4942  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    5043
    5144  /* internal counters */
    5245  Nmatch = 0;
    53   NMEAS = Nmeas = catalog[0].Nmeasure;
     46  NMEAS = Nmeas = tgtcat[0].Nmeasure;
    5447 
    55   // current max obj ID for this catalog
    56   objID = catalog[0].objID;
    57   catID = catalog[0].catID;
     48  off_t *next_meas = NULL;
     49
     50  // current max obj ID for this tgtcat
     51  objID = tgtcat[0].objID;
     52  catID = tgtcat[0].catID;
    5853
    5954  /* project onto rectilinear grid with 1 arcsec pixels. the choice of ARC projection has
    6055   * the advantage that every point in R,D has a mapping to a unique X,Y.  However, note
    6156   * that not all possible X,Y points map back to R,D and the local plate scale changes
    62    * far from the projection pole. We use the center of the region (catalog) for crval1,2.
     57   * substantially far from the projection pole. We use the center of the region (tgtcat)
     58   * for crval1,2.
    6359   */
    6460  InitCoords (&tcoords, "DEC--ARC");
    6561  tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
    66   if (region[0].Dmax < 90) {
     62  if ((region[0].Dmax < 90) && (region[0].Dmin > -90)) {
    6763    tcoords.crval2 = 0.5*(region[0].Dmin + region[0].Dmax);
    6864  } else {
    69     tcoords.crval2 = 90.0;
     65    tcoords.crval2 = (region[0].Dmax >= 90) ? 90.0 : -90.0;
    7066  }
    7167  tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
    … …  
    7369  /* build spatial index (RA sort) referencing input array sequence */
    7470  Nstars = 0;
    75   for (i = 0; i < NstarsIn; i++) {
    76     status = RD_to_XY (&X1[Nstars], &Y1[Nstars], stars[i][0].average.R, stars[i][0].average.D, &tcoords);
     71  for (i = 0; i < srccat->Naverage; i++) {
     72    status = RD_to_XY (&X1[Nstars], &Y1[Nstars], srccat->average[i].R, srccat->average[i].D, &tcoords);
    7773    if (!status) continue;
    7874    N1[Nstars] = i;
    … …  
    8076  }
    8177  if (Nstars < 1) {
    82     if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", catalog[0].filename);
     78    if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", tgtcat[0].filename);
    8379    free (X1);
    8480    free (Y1);
    … …  
    9389  /* build spatial index (RA sort) */
    9490  for (i = 0; i < Nave; i++) {
    95     RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
     91    RD_to_XY (&X2[i], &Y2[i], tgtcat[0].average[i].R, tgtcat[0].average[i].D, &tcoords);
    9692    N2[i] = i;
    97     catalog[0].found_t[N2[i]] = -1;
     93    tgtcat[0].found_t[N2[i]] = -1;
    9894  }
    9995  if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave);
    10096
    10197  /* set up pointers for linked list of measure */
    102   if (catalog[0].sorted && (catalog[0].Nmeasure == catalog[0].Nmeasure_disk)) {
    103     // this version is only valid if we have done a full catalog load, and if the catalog
     98  if (tgtcat[0].sorted && (tgtcat[0].Nmeasure == tgtcat[0].Nmeasure_disk)) {
     99    // this version is only valid if we have done a full tgtcat load, and if the tgtcat
    104100    // is sorted while processed
    105     next_meas = init_measure_links (catalog[0].average, Nave, catalog[0].measure, Nmeas);
     101    next_meas = init_measure_links (tgtcat[0].average, Nave, tgtcat[0].measure, Nmeas);
    106102  } else {
    107     next_meas = build_measure_links (catalog[0].average, Nave, catalog[0].measure, Nmeas);
     103    next_meas = build_measure_links (tgtcat[0].average, Nave, tgtcat[0].measure, Nmeas);
    108104  }   
    109105
    … …  
    116112  RADIUS2 = RADIUS*RADIUS;
    117113
    118   /** find matched stars **/
    119   // XXX could use NREFSTAR_GROUP to do this match more quicky
     114  /****************** find matched stars ********************/
     115
    120116  for (i = j = 0; (i < Nstars) && (j < Nave); ) {
    121117    if (!finite(X1[i]) || !finite(Y1[i])) {
    … …  
    140136    }
    141137
    142     if (stars[N1[i]][0].found != -1) {
    143         /* this star has already been assigned to an object in this or another catalog */
     138    // XXX check that this is allocated
     139    if (srccat->found_t[N1[i]] != -1) {
     140        /* this star has already been assigned to an object in this or another tgtcat */
    144141        i++;
    145142        continue;
    … …  
    169166    /*** a match is found, add to average, measure ***/
    170167    Nmatch ++;
    171     n = N2[Jmin];
    172     N = N1[i];
    173 
    174     /** in replace mode, search for entry and replace values M, dM, R, D */
    175     // XXX this fails for unsorted catalogs, right?
    176     if (options.replace && replace_match (&catalog[0].average[n], catalog[0].measure, stars[N])) {
    177         i++;
    178         continue;
    179     }
     168    off_t n = N2[Jmin];
     169    off_t N = N1[i];
    180170
    181171    /* make sure there is space for next entry */
    182     if (Nmeas >= NMEAS) {
    183       NMEAS = Nmeas + 1000;
     172    if (Nmeas >= NMEAS - srccat->average[N].Nmeasure) {
     173      NMEAS = Nmeas + 1000 + srccat->average[N].Nmeasure;
    184174      REALLOCATE (next_meas, off_t, NMEAS);
    185       REALLOCATE (catalog[0].measure, Measure, NMEAS);
    186     }
    187 
    188     /* add to end of measurement list */
    189     add_meas_link (&catalog[0].average[n], next_meas, Nmeas, NMEAS);
    190        
     175      REALLOCATE (tgtcat[0].measure, Measure, NMEAS);
     176    }
     177
    191178    /** add measurements for this star **/
    192 
    193     // set the new measurements
    194     catalog[0].measure[Nmeas]          = stars[N][0].measure;
    195 
    196     catalog[0].measure[Nmeas].dbFlags  = 0;
    197     catalog[0].measure[Nmeas].averef   = n;
    198     catalog[0].measure[Nmeas].objID    = catalog[0].average[n].objID;
    199     catalog[0].measure[Nmeas].catID    = catalog[0].catID;
    200 
    201     float dRoff = dvoOffsetR(&catalog[0].measure[Nmeas], &catalog[0].average[n]);
    202 
    203     // rationalize dR:
    204     if (dRoff > +180.0*3600.0) {
    205       // average on high end of boundary, move star up
    206       catalog[0].measure[Nmeas].R += 360.0;
    207       dRoff -= 360.0*3600.0;
    208     }
    209     if (dRoff < -180.0*3600.0) {
    210       // average on low end of boundary, move star down
    211       catalog[0].measure[Nmeas].R -= 360.0;
    212       dRoff += 360.0*3600.0;
    213     }
    214 
    215     // the reference data may not have per-object time specified
    216     catalog[0].measure[Nmeas].t        = (TIMEREF == 0) ? stars[N][0].measure.t      : TIMEREF; /** careful : time_t vs e_time **/
    217     catalog[0].measure[Nmeas].t_msec   = (TIMEREF == 0) ? stars[N][0].measure.t_msec : TIMEREF; /** careful : time_t vs e_time **/
    218 
    219     // we can choose to accept the proper-motion and parallax from the reference catalog
    220     if (ACCEPT_MOTION) {
    221       catalog[0].average[n].dR         = stars[N][0].average.dR;
    222       catalog[0].average[n].dD         = stars[N][0].average.dD;
    223       catalog[0].average[n].uR         = stars[N][0].average.uR;
    224       catalog[0].average[n].uD         = stars[N][0].average.uD;
    225       catalog[0].average[n].duR        = stars[N][0].average.duR;
    226       catalog[0].average[n].duD        = stars[N][0].average.duD;
    227       catalog[0].average[n].P          = stars[N][0].average.P;
    228       catalog[0].average[n].dP         = stars[N][0].average.dP;
    229       catalog[0].average[n].Tmean      = stars[N][0].average.Tmean;
    230     }
     179    off_t mOff = srccat->average[N].measureOffset;
     180    for (mSrc = 0; mSrc < srccat->average[N].Nmeasure; mSrc++) {
     181      /** in replace mode, search for entry and replace values M, dM, R, D */
     182      // XXX this fails for unsorted tgtcats, right?
     183      if (options.replace && replace_match (&tgtcat[0].average[n], tgtcat[0].measure, &srccat->measure[mSrc + mOff], &srccat->found_t[N])) continue;
     184
     185      /* add to end of measurement list */
     186      add_meas_link (&tgtcat[0].average[n], next_meas, Nmeas, NMEAS);
     187     
     188      // set the new measurements
     189      tgtcat[0].measure[Nmeas]          = srccat->measure[mSrc + mOff];
     190
     191      // measure now carries R,D (not dR,dD)
     192      tgtcat[0].measure[Nmeas].dbFlags  = 0;
     193      tgtcat[0].measure[Nmeas].averef   = n;
     194      tgtcat[0].measure[Nmeas].objID    = tgtcat[0].average[n].objID;
     195      tgtcat[0].measure[Nmeas].catID    = tgtcat[0].catID;
     196
     197      float dRoff = dvoOffsetR(&tgtcat[0].measure[Nmeas], &tgtcat[0].average[n]);
     198
     199      // rationalize dR:
     200      if (dRoff > +180.0*3600.0) {
     201        // average on high end of boundary, move star up
     202        tgtcat[0].measure[Nmeas].R += 360.0;
     203        dRoff -= 360.0*3600.0;
     204      }
     205      if (dRoff < -180.0*3600.0) {
     206        // average on low end of boundary, move star down
     207        tgtcat[0].measure[Nmeas].R -= 360.0;
     208        dRoff += 360.0*3600.0;
     209      }
     210      if (fabs(dRoff) > 10*RADIUS) {
     211        // take declination into account and check again.
     212        double cosD = cos(RAD_DEG*tgtcat[0].average[n].D);
     213        if (fabs(dRoff*cosD) > 10*RADIUS) {
     214          fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n",
     215                   tgtcat[0].average[n].R, tgtcat[0].average[n].D,
     216                   srccat->average[N].R, srccat->average[N].D,
     217                   X1[i], X2[Jmin],
     218                   Y1[i], Y2[Jmin]);
     219          // XXX abort on this? -- this is a bad failure...
     220        }
     221      }
     222
     223      // the reference data may not have per-object time specified
     224      if (TIMEREF) {
     225        tgtcat[0].measure[Nmeas].t        = TIMEREF;
     226        tgtcat[0].measure[Nmeas].t_msec   = 0;
     227      }
     228
     229      // we can choose to accept the proper-motion and parallax from the reference tgtcat
     230      if (ACCEPT_MOTION) {
     231        tgtcat[0].average[n].dR         = srccat->average[N].dR;
     232        tgtcat[0].average[n].dD         = srccat->average[N].dD;
     233        tgtcat[0].average[n].uR         = srccat->average[N].uR;
     234        tgtcat[0].average[n].uD         = srccat->average[N].uD;
     235        tgtcat[0].average[n].duR        = srccat->average[N].duR;
     236        tgtcat[0].average[n].duD        = srccat->average[N].duD;
     237        tgtcat[0].average[n].P          = srccat->average[N].P;
     238        tgtcat[0].average[n].dP         = srccat->average[N].dP;
     239        tgtcat[0].average[n].Tmean      = srccat->average[N].Tmean;
     240      }
    231241
    232242    /** don't update average / secfilt values for REF photcodes **/
    233243
    234     /*** handle multiple stars */
    235     /* this catalog star matches more than one image star */
    236     // XXX should this be an average flag?
    237     if (catalog[0].found_t[n] > -1) {
    238       catalog[0].measure[catalog[0].found_t[n]].dbFlags |= ID_MEAS_BLEND_OBJ;
    239       catalog[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_OBJ;
    240     } else {
    241       catalog[0].found_t[n] = Nmeas;
    242     }
    243 
    244     stars[N][0].found = Nmeas;
    245     catalog[0].average[n].Nmeasure ++;
    246     Nmeas ++;
    247 
    248     // make this optional:
    249     // update_coords (&catalog[0].average[n], &catalog[0].measure[0], next_meas);
     244      tgtcat[0].average[n].Nmeasure ++;
     245      Nmeas ++;
     246    }
     247
     248    srccat->found_t[N] = n;
     249    tgtcat[0].found_t[n] = -1;
    250250    i++;
    251251  }
     252
     253  /*************** add unmatched stars *************************/
    252254
    253255  /* Incorporate unmatched refcat stars.  Skip this step if we want to
    … …  
    255257     reference up-to-date with known stars only */
    256258
    257   for (i = 0; (i < Nstars) && !options.only_match; i+=NREFSTAR_GROUP) {
     259  for (i = 0; (i < Nstars) && !options.only_match; i++) {
    258260    /* make sure there is space for next entry */
    259     if (Nmeas >= NMEAS - NREFSTAR_GROUP) {
    260       NMEAS = Nmeas + 1000;
     261    if (Nmeas >= NMEAS - srccat->average[i].Nmeasure) {
     262      NMEAS = Nmeas + 1000 + srccat->average[i].Nmeasure;
    261263      REALLOCATE (next_meas, off_t, NMEAS);
    262       REALLOCATE (catalog[0].measure, Measure, NMEAS);
     264      REALLOCATE (tgtcat[0].measure, Measure, NMEAS);
    263265    }
    264266    if (Nave >= NAVE) {
    265267      NAVE = Nave + 1000;
    266       REALLOCATE (catalog[0].average, Average, NAVE);
    267       REALLOCATE (catalog[0].secfilt, SecFilt, NAVE*catalog[0].Nsecfilt);
    268     }
    269 
    270     N = N1[i];
    271     if (stars[N][0].found >= 0) continue;
    272     if (!IN_REGION (stars[N][0].average.R, stars[N][0].average.D)) continue;
    273 
    274     dvo_average_init (&catalog[0].average[Nave]);
    275     catalog[0].average[Nave].R             = stars[N][0].average.R;
    276     catalog[0].average[Nave].D             = stars[N][0].average.D;
    277 
    278     catalog[0].average[Nave].Nmeasure      = NREFSTAR_GROUP;
    279     catalog[0].average[Nave].measureOffset = Nmeas;
    280     catalog[0].average[Nave].objID         = objID;
    281     catalog[0].average[Nave].catID         = catID;
     268      REALLOCATE (tgtcat[0].average, Average, NAVE);
     269      REALLOCATE (tgtcat[0].found_t, off_t, NAVE);
     270      if (tgtcat[0].secfilt) {
     271        // we only update the secfilt table if it has been allocated for output
     272        REALLOCATE (tgtcat[0].secfilt, SecFilt, NAVE*tgtcat[0].Nsecfilt);
     273      }
     274    }
     275
     276    if (srccat->found_t[i] != -1) continue;
     277    if (!IN_REGION (srccat->average[i].R, srccat->average[i].D)) continue;
     278
     279    dvo_average_init (&tgtcat[0].average[Nave]);
     280    tgtcat[0].average[Nave].R              = srccat->average[i].R;
     281    tgtcat[0].average[Nave].D              = srccat->average[i].D;
     282
     283    tgtcat[0].average[Nave].Nmeasure       = srccat->average[i].Nmeasure;
     284    tgtcat[0].average[Nave].measureOffset  = Nmeas;
     285    tgtcat[0].average[Nave].objID          = objID;
     286    tgtcat[0].average[Nave].catID          = catID;
    282287
    283288    if (PSPS_ID) {
    284         catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D);
     289        tgtcat[0].average[Nave].extID = CreatePSPSObjectID(tgtcat[0].average[Nave].R, tgtcat[0].average[Nave].D);
    285290    }
    286291
    287292    if (ACCEPT_MOTION) {
    288       catalog[0].average[Nave].dR          = stars[N][0].average.dR;
    289       catalog[0].average[Nave].dD          = stars[N][0].average.dD;
    290       catalog[0].average[Nave].uR          = stars[N][0].average.uR;
    291       catalog[0].average[Nave].uD          = stars[N][0].average.uD;
    292       catalog[0].average[Nave].duR         = stars[N][0].average.duR;
    293       catalog[0].average[Nave].duD         = stars[N][0].average.duD;
    294       catalog[0].average[Nave].P           = stars[N][0].average.P;
    295       catalog[0].average[Nave].dP          = stars[N][0].average.dP;
    296       catalog[0].average[Nave].Tmean       = stars[N][0].average.Tmean;
     293      tgtcat[0].average[Nave].dR           = srccat->average[i].dR;
     294      tgtcat[0].average[Nave].dD           = srccat->average[i].dD;
     295      tgtcat[0].average[Nave].uR           = srccat->average[i].uR;
     296      tgtcat[0].average[Nave].uD           = srccat->average[i].uD;
     297      tgtcat[0].average[Nave].duR          = srccat->average[i].duR;
     298      tgtcat[0].average[Nave].duD          = srccat->average[i].duD;
     299      tgtcat[0].average[Nave].P            = srccat->average[i].P;
     300      tgtcat[0].average[Nave].dP           = srccat->average[i].dP;
     301      tgtcat[0].average[Nave].Tmean        = srccat->average[i].Tmean;
    297302    }
    298303
    … …  
    300305
    301306    for (j = 0; j < Nsecfilt; j++) {
    302       dvo_secfilt_init (&catalog[0].secfilt[Nave*Nsecfilt+j], SECFILT_RESET_ALL);
    303     }
    304 
    305     for (j = 0; j < NREFSTAR_GROUP; j++) {
    306       N = N1[i + j];
    307 
    308       catalog[0].measure[Nmeas]          = stars[N][0].measure;
    309       catalog[0].measure[Nmeas].dbFlags  = 0;
    310       catalog[0].measure[Nmeas].averef   = Nave;
    311       catalog[0].measure[Nmeas].objID    = catalog[0].average[Nave].objID;
    312       catalog[0].measure[Nmeas].catID    = catalog[0].catID;
    313 
    314       catalog[0].measure[Nmeas].t        = (stars[N][0].measure.t == 0) ? TIMEREF : stars[N][0].measure.t;      /** careful : time_t vs e_time **/
    315       catalog[0].measure[Nmeas].t_msec   = (stars[N][0].measure.t == 0) ?       0 : stars[N][0].measure.t_msec; /** careful : time_t vs e_time **/
    316 
    317       stars[N][0].found = Nmeas;
    318       next_meas[Nmeas] = -1;
     307      dvo_secfilt_init (&tgtcat[0].secfilt[Nave*Nsecfilt+j], SECFILT_RESET_ALL);
     308    }
     309
     310    off_t mOff = srccat->average[i].measureOffset;
     311    for (mSrc = 0; mSrc < srccat->average[i].Nmeasure; mSrc++) {
     312      // supply the measurements from this detection
     313      dvo_measure_init (&tgtcat[0].measure[Nmeas]);
     314      tgtcat[0].measure[Nmeas] = srccat->measure[mSrc + mOff];
     315
     316      // the following measure elements cannot be set until here:
     317      tgtcat[0].measure[Nmeas].dbFlags  = 0;
     318      tgtcat[0].measure[Nmeas].averef   = Nave;
     319      tgtcat[0].measure[Nmeas].objID    = tgtcat[0].average[Nave].objID;
     320      tgtcat[0].measure[Nmeas].catID    = tgtcat[0].catID;
     321
     322      if (TIMEREF) {
     323        tgtcat[0].measure[Nmeas].t      = TIMEREF;
     324        tgtcat[0].measure[Nmeas].t_msec = 0;
     325      }
     326
    319327      Nmeas ++;
    320     }
    321     for (j = 0; j < NREFSTAR_GROUP - 1; j++) {
    322         next_meas[Nmeas - NREFSTAR_GROUP + j] = Nmeas - NREFSTAR_GROUP + j + 1;
    323     }
     328
     329      // update the next_meas pointer for this entry (last one for this star is -1)
     330      next_meas[Nmeas-1] = (mSrc < srccat->average[i].Nmeasure - 1) ? Nmeas : -1;
     331    }
     332    srccat->found_t[i] = Nave;
    324333    Nave ++;
    325334  }
    326335     
    327   REALLOCATE (catalog[0].average, Average, Nave);
    328   REALLOCATE (catalog[0].measure, Measure, Nmeas);
     336  REALLOCATE (tgtcat[0].average, Average, Nave);
     337  REALLOCATE (tgtcat[0].measure, Measure, Nmeas);
    329338
    330339  // XXX allow for unsorted output?
    331   catalog[0].measure = sort_measure (catalog[0].average, Nave, catalog[0].measure, Nmeas, next_meas);
    332   catalog[0].sorted = TRUE;
    333 
    334   /* note stars which have been found in this catalog */
    335   for (i = 0; i < Nstars; i++) {
    336     if (stars[i][0].found > -1) {
    337       stars[i][0].found = -2;
    338     }
    339   }
    340 
    341   catalog[0].objID    = objID; // new max value, save on catalog close
    342   catalog[0].Naverage = Nave;
    343   catalog[0].Nmeasure = Nmeas;
    344   catalog[0].Nsecfilt_mem = Nave*Nsecfilt;
     340  tgtcat[0].measure = sort_measure (tgtcat[0].average, Nave, tgtcat[0].measure, Nmeas, next_meas);
     341  tgtcat[0].sorted = TRUE;
     342
     343  /* note stars which have been found in this tgtcat */
     344  for (i = 0; i < srccat->Naverage; i++) {
     345    if (srccat->found_t[i] > -1) {
     346      srccat->found_t[i] = -2;
     347    }
     348  }
     349
     350  /* check if the tgtcat has changed?  if no change, no need to write */
     351  tgtcat[0].objID    = objID; // new max value, save on tgtcat close
     352  tgtcat[0].Naverage = Nave;
     353  tgtcat[0].Nmeasure = Nmeas;
     354  tgtcat[0].Nsecfilt_mem = Nave*Nsecfilt;
    345355  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n",  Nstars,  Nave,  Nmeas,  Nmatch);
    346356
    … …  
    348358  free (Y1);
    349359  free (N1);
    350   free (N2);
    351360  free (X2);
    352361  free (Y2);
     362  free (N2);
    353363  free (next_meas);
    354364
    355365  return (Nmatch);
    356366}
     367
     368/* differences with find_matches_closest():
     369 * accepts Stars **stars (vs Stars *stars)
     370 * NREFSTAR_GROUP vs NSTAR_GROUP
     371 * does not update lensing fields
     372 * allows option to replace existing entries
     373 * allows multiple photcodes
     374
     375 */
     376

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

    r38467 r38986  
    11# include "addstar.h"
    22
    3 int find_matches_refstars (SkyRegion *region, Stars **stars, unsigned int Nstars, Catalog *catalog, AddstarClientOptions options) {
    4 
    5   off_t i, j, n, N, J;
     3// see bottom of this file for differences between find_matches_refstars.c and find_matches.c
     4int find_matches_refstars (SkyRegion *region, Catalog *srccat, Catalog *tgtcat, AddstarClientOptions options) {
     5
     6  off_t i, j, J, Nstars, mSrc;
    67  double RADIUS, RADIUS2;
    78  double *X1, *Y1, *X2, *Y2;
    89  double dX, dY, dR;
    9   off_t *N1, *N2,  *next_meas;
     10  off_t *N1, *N2;
    1011  off_t Nave, NAVE, Nmeas, NMEAS, Nmatch;
    1112  unsigned int objID, catID;
    … …  
    1314  int Nsecfilt;
    1415
    15   switch (NREFSTAR_GROUP) {
    16     case 1:
    17     case 3:
    18     case 4:
    19       break;
    20     default:
    21       fprintf (stderr, "ERROR: NREFSTAR_GROUP NOT SET!\n");
    22       exit (1);
    23   }
    24 
    2516  /* photcode data -- should not have to modify secfilt / average */
    2617  Nsecfilt = GetPhotcodeNsecfilt ();
    2718
    2819  /** allocate local arrays (stars) **/
    29   ALLOCATE (X1, double, Nstars);
    30   ALLOCATE (Y1, double, Nstars);
    31   ALLOCATE (N1, off_t,  Nstars);
    32 
    33   /** allocate local arrays (catalog) **/
    34   Nave = catalog[0].Naverage;
    35   NAVE = Nave + 1000;
     20  ALLOCATE (X1, double, srccat->Naverage);
     21  ALLOCATE (Y1, double, srccat->Naverage);
     22  ALLOCATE (N1, off_t,  srccat->Naverage);
     23
     24  myAbort ("figure out if found_t needs to be tracking Naverage or Nmeasure");
     25  if (!srccat->found_t) {
     26    ALLOCATE (srccat->found_t, off_t, srccat->Naverage);
     27    for (i = 0; i < srccat->Naverage; i++) {
     28      srccat->found_t[i] = -1;
     29    }
     30  }
     31
     32  /** allocate local arrays (tgtcat) **/
     33  NAVE = Nave = tgtcat[0].Naverage;
    3634  ALLOCATE (X2, double, NAVE);
    3735  ALLOCATE (Y2, double, NAVE);
    3836  ALLOCATE (N2, off_t,  NAVE);
    39   ALLOCATE (catalog[0].found_t, off_t, NAVE);
    40   REALLOCATE (catalog[0].average, Average, NAVE);
    41   REALLOCATE (catalog[0].secfilt, SecFilt, NAVE*catalog[0].Nsecfilt);
     37
     38  if (!tgtcat->found_t) {
     39    ALLOCATE (tgtcat[0].found_t, off_t, NAVE);
     40    for (i = 0; i < NAVE; i++) {
     41      tgtcat->found_t[i] = -1;
     42    }
     43  }
    4244  /* for secfilt j and star i, secfilt[i*Nsecfilt+j] */
    4345
     46  /* internal counters */
    4447  Nmatch = 0;
    45   NMEAS = Nmeas = catalog[0].Nmeasure;
     48  NMEAS = Nmeas = tgtcat[0].Nmeasure;
    4649 
    47   // current max obj ID for this catalog
    48   objID = catalog[0].objID;
    49   catID = catalog[0].catID;
    50 
    51   /* project onto rectilinear grid with 1 arcsec pixels, sort by X */
    52   /* reference for coords is catalog center */
    53   InitCoords (&tcoords, "DEC--ZEA");
     50  off_t *next_meas = NULL;
     51
     52  // current max obj ID for this tgtcat
     53  objID = tgtcat[0].objID;
     54  catID = tgtcat[0].catID;
     55
     56  /* project onto rectilinear grid with 1 arcsec pixels. the choice of ARC projection has
     57   * the advantage that every point in R,D has a mapping to a unique X,Y.  However, note
     58   * that not all possible X,Y points map back to R,D and the local plate scale changes
     59   * substantially far from the projection pole.  We use the center of the region (tgtcat)
     60   * for crval1,2.
     61   */
     62  InitCoords (&tcoords, "DEC--ARC");
    5463  tcoords.crval1 = 0.5*(region[0].Rmin + region[0].Rmax);
    55   tcoords.crval2 = 0.5*(region[0].Dmin + region[0].Dmax);
     64  if ((region[0].Dmax < 90) && (region[0].Dmin > -90)) {
     65    tcoords.crval2 = 0.5*(region[0].Dmin + region[0].Dmax);
     66  } else {
     67    tcoords.crval2 = (region[0].Dmax >= 90) ? 90.0 : -90.0;
     68  }
    5669  tcoords.cdelt1 = tcoords.cdelt2 = 1.0 / 3600.0;
    57  
    58   for (i = 0; i < Nstars; i++) {
    59     RD_to_XY (&X1[i], &Y1[i], stars[i][0].average.R, stars[i][0].average.D, &tcoords);
    60     N1[i] = i;
     70
     71  /* build spatial index (RA sort) referencing input array sequence */
     72  Nstars = 0;
     73  for (i = 0; i < srccat->Naverage; i++) {
     74    int status = RD_to_XY (&X1[Nstars], &Y1[Nstars], srccat->average[i].R, srccat->average[i].D, &tcoords);
     75    if (!status) continue;
     76    N1[Nstars] = i;
     77    Nstars ++;
     78  }
     79  if (Nstars < 1) {
     80    if (VERBOSE) fprintf (stderr, "skipping %s, no overlapping stars\n", tgtcat[0].filename);
     81    free (X1);
     82    free (Y1);
     83    free (N1);
     84    free (X2);
     85    free (Y2);
     86    free (N2);
     87    return (0);
    6188  }
    6289  if (Nstars > 1) sort_coords_index (X1, Y1, N1, Nstars);
    6390 
     91  /* build spatial index (RA sort) */
    6492  for (i = 0; i < Nave; i++) {
    65     RD_to_XY (&X2[i], &Y2[i], catalog[0].average[i].R, catalog[0].average[i].D, &tcoords);
     93    RD_to_XY (&X2[i], &Y2[i], tgtcat[0].average[i].R, tgtcat[0].average[i].D, &tcoords);
    6694    N2[i] = i;
    67     catalog[0].found_t[N2[i]] = -1;
     95    tgtcat[0].found_t[N2[i]] = -1;
    6896  }
    6997  if (Nave > 1) sort_coords_index (X2, Y2, N2, Nave);
    7098
    7199  /* set up pointers for linked list of measurements */
    72   if (catalog[0].sorted && (catalog[0].Nmeasure == catalog[0].Nmeasure_disk)) {
     100  if (tgtcat[0].sorted && (tgtcat[0].Nmeasure == tgtcat[0].Nmeasure_disk)) {
    73101    // this version is only valid if we have done a full catalog load, and if the catalog
    74102    // is sorted while processed
    75     next_meas = init_measure_links (catalog[0].average, Nave, catalog[0].measure, Nmeas);
     103    next_meas = init_measure_links (tgtcat[0].average, Nave, tgtcat[0].measure, Nmeas);
    76104  } else {
    77     next_meas = build_measure_links (catalog[0].average, Nave, catalog[0].measure, Nmeas);
     105    next_meas = build_measure_links (tgtcat[0].average, Nave, tgtcat[0].measure, Nmeas);
    78106  }   
    79107
    80   /* choose a radius for matches */
     108  /* choose a radius for matches (defined in args.c or ImageOptions.c) */
    81109  if (options.radius == 0) {
    82110    RADIUS = 2.0; /* hardwired default for refstars */
    … …  
    86114  RADIUS2 = RADIUS*RADIUS;
    87115
    88   /** find matched stars **/
    89   // XXX could use NREFSTAR_GROUP to do this match more quicky
     116  /****************** find matched stars ********************/
     117
    90118  for (i = j = 0; (i < Nstars) && (j < Nave); ) {
    91119    if (!finite(X1[i]) || !finite(Y1[i])) {
    … …  
    97125      continue;
    98126    }
    99    
     127
     128    /* negative dX: j is too large */
    100129    dX = X1[i] - X2[j];
    101130    if (dX <= -1.02*RADIUS) {
    … …  
    103132      continue;
    104133    }
     134    /* positive dX, i is too large */
    105135    if (dX >= 1.02*RADIUS) {
    106136      j++;
    … …  
    108138    }
    109139
    110     /* negative dX: j is too large, positive dX, i is too large */
     140    /* within match range; look for matches */
    111141    for (J = j; (dX > -1.02*RADIUS) && (J < Nave); J++) {
    112142      dX = X1[i] - X2[J];
    … …  
    117147      /*** a match is found, add to average, measure ***/
    118148      Nmatch ++;
    119       n = N2[J];
    120       N = N1[i];
    121 
    122       /** in replace mode, search for entry and replace values M, dM, R, D */
    123       if (options.replace && replace_match (&catalog[0].average[n], catalog[0].measure, stars[N])) continue;
    124 
    125       if (Nmeas == NMEAS) {
    126         NMEAS = Nmeas + 1000;
     149      off_t n = N2[J];
     150      off_t N = N1[i];
     151
     152      /* make sure there is space for next entry */
     153      if (Nmeas >= NMEAS - srccat->average[N].Nmeasure) {
     154        NMEAS = Nmeas + 1000 + srccat->average[N].Nmeasure;
    127155        REALLOCATE (next_meas, off_t, NMEAS);
    128         REALLOCATE (catalog[0].measure, Measure, NMEAS);
     156        REALLOCATE (tgtcat[0].measure, Measure, NMEAS);
    129157      }
    130158
    131       /* add to end of measurement list */
    132       add_meas_link (&catalog[0].average[n], next_meas, Nmeas, NMEAS);
     159      /** add measurements for this star **/
     160      off_t mOff = srccat->average[N].measureOffset;
     161      for (mSrc = 0; mSrc < srccat->average[N].Nmeasure; mSrc++) {
     162        /** in replace mode, search for entry and replace values M, dM, R, D */
     163        if (options.replace && replace_match (&tgtcat[0].average[n], tgtcat[0].measure, &srccat->measure[mSrc + mOff], &srccat->found_t[N])) continue;
     164
     165        /* add to end of measurement list */
     166        add_meas_link (&tgtcat[0].average[n], next_meas, Nmeas, NMEAS);
    133167       
    134       /** add measurements for this star **/
    135 
    136       // set the new measurements
    137       catalog[0].measure[Nmeas]          = stars[N][0].measure;
    138 
    139       /** measure now stores R,D **/
    140       catalog[0].measure[Nmeas].dbFlags  = 0;
    141       catalog[0].measure[Nmeas].averef   = n;
    142       catalog[0].measure[Nmeas].objID    = catalog[0].average[n].objID;
    143       catalog[0].measure[Nmeas].catID    = catalog[0].catID;
    144 
    145       float dRoff = dvoOffsetR(&catalog[0].measure[Nmeas], &catalog[0].average[n]);
    146 
    147       // rationalize dR:
    148       if (dRoff > +180.0*3600.0) {
     168        /** add measurements for this star **/
     169
     170        // set the new measurements
     171        tgtcat[0].measure[Nmeas]          = srccat->measure[mSrc + mOff];
     172       
     173        // the following measure elements cannot be set until here:
     174        tgtcat[0].measure[Nmeas].dbFlags  = 0;
     175        tgtcat[0].measure[Nmeas].averef   = n; // this must be an absolute sequence number, if partial average is loaded
     176        tgtcat[0].measure[Nmeas].objID    = tgtcat[0].average[n].objID;
     177        tgtcat[0].measure[Nmeas].catID    = tgtcat[0].catID;
     178
     179        float dRoff = dvoOffsetR(&tgtcat[0].measure[Nmeas], &tgtcat[0].average[n]);
     180
     181        // rationalize R:
     182        if (dRoff > +180.0*3600.0) {
    149183          // average on high end of boundary, move star up
    150           catalog[0].measure[Nmeas].R += 360.0;
     184          tgtcat[0].measure[Nmeas].R += 360.0;
    151185          dRoff -= 360.0*3600.0;
     186        }
     187        if (dRoff < -180.0*3600.0) {
     188          // average on low end of boundary, move star down
     189          tgtcat[0].measure[Nmeas].R -= 360.0;
     190          dRoff += 360.0*3600.0;
     191        }
     192        if (fabs(dRoff) > 10*RADIUS) {
     193          // take declination into account and check again.
     194          double cosD = cos(RAD_DEG*tgtcat[0].average[n].D);
     195          if (fabs(dRoff*cosD) > 10*RADIUS) {
     196            fprintf (stderr, "error: %10.6f,%10.6f vs %10.6f,%10.6f (%f,%f vs %f,%f)\n",
     197                     tgtcat[0].average[n].R, tgtcat[0].average[n].D,
     198                     srccat->average[N].R, srccat->average[N].D,
     199                     X1[i], X2[J],
     200                     Y1[i], Y2[J]);
     201          }
     202        }
     203
     204        if (TIMEREF) {
     205          tgtcat[0].measure[Nmeas].t        = TIMEREF; /** careful : time_t vs e_time **/
     206          tgtcat[0].measure[Nmeas].t_msec   = 0;
     207        }
     208
     209        if (ACCEPT_MOTION) {
     210          tgtcat[0].average[n].uR         = srccat->average[N].uR;
     211          tgtcat[0].average[n].uD         = srccat->average[N].uD;
     212          tgtcat[0].average[n].duR        = srccat->average[N].duR;
     213          tgtcat[0].average[n].duD        = srccat->average[N].duD;
     214          tgtcat[0].average[n].P          = srccat->average[N].P;
     215          tgtcat[0].average[n].dP         = srccat->average[N].dP;
     216        }
     217
     218        /** don't update average / secfilt values for REF photcodes **/
     219
     220        myAbort ("fix logic on multiple detections");
     221
     222        /*** flag multiple stars */
     223        /* this image star matches more than one tgtcat star */
     224        if (srccat->found_t[N] > -1) {
     225          tgtcat[0].measure[srccat->found_t[N]].dbFlags |= ID_MEAS_BLEND_MEAS;
     226          tgtcat[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_MEAS;
     227        }
     228        if (srccat->found_t[N] == -2) { /* this image star matches a tgtcat star on a neighboring tgtcat */
     229          tgtcat[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_MEAS_X;
     230        }
     231        if (srccat->found_t[N] == -1) { /* this image star matches only this tgtcat star */
     232          srccat->found_t[N] = Nmeas;  /* save first match, in case coincidences are found */
     233        }
     234        /* this tgtcat star matches more than one image star */
     235        if (tgtcat[0].found_t[n] > -1) {
     236          tgtcat[0].measure[tgtcat[0].found_t[n]].dbFlags |= ID_MEAS_BLEND_OBJ;
     237          tgtcat[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_OBJ;
     238        } else {
     239          tgtcat[0].found_t[n] = Nmeas;
     240        }
     241        tgtcat[0].average[n].Nmeasure ++;
     242        Nmeas ++;
    152243      }
    153       if (dRoff < -180.0*3600.0) {
    154           // average on low end of boundary, move star down
    155           catalog[0].measure[Nmeas].R -= 360.0;
    156           dRoff += 360.0*3600.0;
    157       }
    158 
    159       catalog[0].measure[Nmeas].t        = (TIMEREF == 0) ? stars[N][0].measure.t      : TIMEREF; /** careful : time_t vs e_time **/
    160       catalog[0].measure[Nmeas].t_msec   = (TIMEREF == 0) ? stars[N][0].measure.t_msec : TIMEREF; /** careful : time_t vs e_time **/
    161 
    162       if (ACCEPT_MOTION) {
    163         catalog[0].average[n].uR         = stars[N][0].average.uR;
    164         catalog[0].average[n].uD         = stars[N][0].average.uD;
    165         catalog[0].average[n].duR        = stars[N][0].average.duR;
    166         catalog[0].average[n].duD        = stars[N][0].average.duD;
    167         catalog[0].average[n].P          = stars[N][0].average.P;
    168         catalog[0].average[n].dP         = stars[N][0].average.dP;
    169       }
    170 
    171       /** don't update average / secfilt values for REF photcodes **/
    172 
    173       /*** handle multiple stars */
    174       /* this image star matches more than one catalog star */
    175       if (stars[N][0].found > -1) {
    176         catalog[0].measure[stars[N][0].found].dbFlags |= ID_MEAS_BLEND_MEAS;
    177         catalog[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_MEAS;
    178       }
    179       if (stars[N][0].found == -2) { /* this image star matches a catalog star on a neighboring catalog */
    180         catalog[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_MEAS_X;
    181       }
    182       if (stars[N][0].found == -1) { /* this image star matches only this catalog star */
    183         stars[N][0].found = Nmeas;  /* save first match, in case coincidences are found */
    184       }
    185       /* this catalog star matches more than one image star */
    186       if (catalog[0].found_t[n] > -1) {
    187         catalog[0].measure[catalog[0].found_t[n]].dbFlags |= ID_MEAS_BLEND_OBJ;
    188         catalog[0].measure[Nmeas].dbFlags |= ID_MEAS_BLEND_OBJ;
    189       } else {
    190         catalog[0].found_t[n] = Nmeas;
    191       }
    192 
    193       catalog[0].average[n].Nmeasure ++;
    194       Nmeas ++;
    195 
    196       // update_coords (&catalog[0].average[n], &catalog[0].measure[0], next_meas);
     244     
     245      // update_coords (&tgtcat[0].average[n], &tgtcat[0].measure[0], next_meas);
    197246    }
    198247    i++;
    199248  }
    200 
    201   /* we don't add missed entries for refcat
    202      (already in database, not refcat) */
    203249
    204250  /* incorporate unmatched refcat stars */
    … …  
    207253     the reference up-to-date with known stars only */
    208254
    209   for (i = 0; (i < Nstars) && !options.only_match; i+=NREFSTAR_GROUP) {
    210     if (Nmeas >= NMEAS - NREFSTAR_GROUP) {
    211       NMEAS = Nmeas + 1000;
     255  for (i = 0; (i < Nstars) && !options.only_match; i++) {
     256    /* make sure there is space for next entry */
     257    if (Nmeas >= NMEAS - srccat->average[i].Nmeasure) {
     258      NMEAS = Nmeas + 1000 + srccat->average[i].Nmeasure;
    212259      REALLOCATE (next_meas, off_t, NMEAS);
    213       REALLOCATE (catalog[0].measure, Measure, NMEAS);
    214     }
    215     if (Nave == NAVE) {
     260      REALLOCATE (tgtcat[0].measure, Measure, NMEAS);
     261    }
     262    if (Nave >= NAVE) {
    216263      NAVE = Nave + 1000;
    217       REALLOCATE (catalog[0].average, Average, NAVE);
    218       REALLOCATE (catalog[0].secfilt, SecFilt, NAVE*catalog[0].Nsecfilt);
    219     }
    220 
    221     N = i;
    222     if (stars[N][0].found > -1) continue;
    223     if (!IN_REGION (stars[N][0].average.R, stars[N][0].average.D)) continue;
    224 
    225     dvo_average_init (&catalog[0].average[Nave]);
    226     catalog[0].average[Nave].R             = stars[N][0].average.R;
    227     catalog[0].average[Nave].D             = stars[N][0].average.D;
    228 
    229     catalog[0].average[Nave].Nmeasure      = NREFSTAR_GROUP;
    230     catalog[0].average[Nave].measureOffset = Nmeas;
    231     catalog[0].average[Nave].objID         = objID;
    232     catalog[0].average[Nave].catID         = catID;
     264      REALLOCATE (tgtcat[0].average, Average, NAVE);
     265      if (tgtcat[0].secfilt) {
     266        // we only update the secfilt table if it has been allocated for output
     267        REALLOCATE (tgtcat[0].secfilt, SecFilt, NAVE*tgtcat[0].Nsecfilt);
     268      }
     269    }
     270
     271    if (srccat->found_t[i] >= 0) continue;
     272    if (!IN_REGION (srccat->average[i].R, srccat->average[i].D)) continue;
     273
     274    dvo_average_init (&tgtcat[0].average[Nave]);
     275    tgtcat[0].average[Nave].R              = srccat->average[i].R;
     276    tgtcat[0].average[Nave].D              = srccat->average[i].D;
     277
     278    tgtcat[0].average[Nave].Nmeasure       = srccat->average[i].Nmeasure;
     279    tgtcat[0].average[Nave].measureOffset  = Nmeas;
     280    tgtcat[0].average[Nave].objID          = objID;
     281    tgtcat[0].average[Nave].catID          = catID;
    233282
    234283    if (PSPS_ID) {
    235         catalog[0].average[Nave].extID = CreatePSPSObjectID(catalog[0].average[Nave].R, catalog[0].average[Nave].D);
     284      tgtcat[0].average[Nave].extID = CreatePSPSObjectID(tgtcat[0].average[Nave].R, tgtcat[0].average[Nave].D);
    236285    }
    237286
    238287    if (ACCEPT_MOTION) {
    239       catalog[0].average[Nave].dR          = stars[N][0].average.dR;
    240       catalog[0].average[Nave].dD          = stars[N][0].average.dD;
    241       catalog[0].average[Nave].uR          = stars[N][0].average.uR;
    242       catalog[0].average[Nave].uD          = stars[N][0].average.uD;
    243       catalog[0].average[Nave].duR         = stars[N][0].average.duR;
    244       catalog[0].average[Nave].duD         = stars[N][0].average.duD;
    245       catalog[0].average[Nave].P           = stars[N][0].average.P;
    246       catalog[0].average[Nave].dP          = stars[N][0].average.dP;
     288      tgtcat[0].average[Nave].dR           = srccat->average[i].dR;
     289      tgtcat[0].average[Nave].dD           = srccat->average[i].dD;
     290      tgtcat[0].average[Nave].uR           = srccat->average[i].uR;
     291      tgtcat[0].average[Nave].uD           = srccat->average[i].uD;
     292      tgtcat[0].average[Nave].duR          = srccat->average[i].duR;
     293      tgtcat[0].average[Nave].duD          = srccat->average[i].duD;
     294      tgtcat[0].average[Nave].P            = srccat->average[i].P;
     295      tgtcat[0].average[Nave].dP           = srccat->average[i].dP;
    247296    }
    248297
    249298    objID ++;
    250299
    251     for (j = 0; j < Nsecfilt; j++) {
    252       dvo_secfilt_init (&catalog[0].secfilt[Nave*Nsecfilt+j], SECFILT_RESET_ALL);
    253     }
    254 
    255     for (j = 0; j < NREFSTAR_GROUP; j++) {
    256       N = i + j;
    257 
    258       catalog[0].measure[Nmeas]          = stars[N][0].measure;
    259 
    260       catalog[0].measure[Nmeas].t        = (stars[N][0].measure.t == 0) ? TIMEREF : stars[N][0].measure.t;      /** careful : time_t vs e_time **/
    261       catalog[0].measure[Nmeas].t_msec   = (stars[N][0].measure.t == 0) ?       0 : stars[N][0].measure.t_msec; /** careful : time_t vs e_time **/
    262       catalog[0].measure[Nmeas].dbFlags  = 0;
    263       catalog[0].measure[Nmeas].averef   = Nave;
    264       catalog[0].measure[Nmeas].objID    = catalog[0].average[Nave].objID;
    265       catalog[0].measure[Nmeas].catID    = catalog[0].catID;
    266 
    267       stars[N][0].found = Nmeas;
    268       next_meas[Nmeas] = -1;  // initial value here, update below
    269       Nmeas ++;
    270     }
    271 
    272     for (j = 0; j < NREFSTAR_GROUP - 1; j++) {
    273         next_meas[Nmeas - NREFSTAR_GROUP + j] = Nmeas - NREFSTAR_GROUP + j + 1;
     300    for (j = 0; tgtcat[0].secfilt && (j < Nsecfilt); j++) {
     301      dvo_secfilt_init (&tgtcat[0].secfilt[Nave*Nsecfilt+j], SECFILT_RESET_ALL);
     302    }
     303
     304    off_t mOff = srccat->average[i].measureOffset;
     305    for (mSrc = 0; mSrc < srccat->average[i].Nmeasure; mSrc++) {
     306      // supply the measurments from this detection
     307      dvo_measure_init (&tgtcat[0].measure[Nmeas]);
     308      tgtcat[0].measure[Nmeas] = srccat->measure[mSrc + mOff];
     309
     310      // the following measure elements cannot be set until here:
     311      tgtcat[0].measure[Nmeas].dbFlags   = 0;
     312      tgtcat[0].measure[Nmeas].averef    = Nave; // XXX EAM : must be absolute Nave if partial read
     313      tgtcat[0].measure[Nmeas].objID     = tgtcat[0].average[Nave].objID;
     314      tgtcat[0].measure[Nmeas].catID     = tgtcat[0].catID;
     315
     316      if (TIMEREF) {
     317        tgtcat[0].measure[Nmeas].t        = TIMEREF;
     318        tgtcat[0].measure[Nmeas].t_msec   =       0;
     319      }
     320
     321      /* next[Nmeas] should always be -1 in this context (it is always the only
     322         measurement for the star) */
     323      srccat->found_t[i] = Nmeas;
     324      Nmeas ++;
     325
     326      // update the next_meas pointer for this entry (last one for this star is -1)
     327      next_meas[Nmeas-1] = (mSrc < srccat->average[i].Nmeasure - 1) ? Nmeas : -1;
    274328    }
    275329    Nave ++;
    276330  }
    277331     
    278   REALLOCATE (catalog[0].average, Average, Nave);
     332  REALLOCATE (tgtcat[0].average, Average, Nave);
     333  REALLOCATE (tgtcat[0].measure, Measure, Nmeas);
    279334
    280335  // XXX allow for unsorted output?
    281   catalog[0].measure = sort_measure (catalog[0].average, Nave, catalog[0].measure, Nmeas, next_meas);
    282 
    283   /* note stars which have been found in this catalog */
    284   for (i = 0; i < Nstars; i++) {
    285     if (stars[i][0].found > -1) {
    286       stars[i][0].found = -2;
    287     } else {
    288       stars[i][0].found = -3;
    289     }
    290   }
    291 
    292   catalog[0].objID    = objID; // new max value, save on catalog close
    293   catalog[0].Naverage = Nave;
    294   catalog[0].Nmeasure = Nmeas;
    295   catalog[0].Nsecfilt_mem = Nave*Nsecfilt;
    296   if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: %d "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n",  Nstars,  Nave,  Nmeas,  Nmatch);
     336  tgtcat[0].measure = sort_measure (tgtcat[0].average, Nave, tgtcat[0].measure, Nmeas, next_meas);
     337
     338  /* note stars which have been found in this tgtcat */
     339  for (i = 0; i < srccat->Nmeasure; i++) {
     340    if (srccat->found_t[i] > -1) {
     341      srccat->found_t[i] = -2;
     342    }
     343  }
     344
     345  tgtcat[0].objID    = objID; // new max value, save on tgtcat close
     346  tgtcat[0].Naverage = Nave;
     347  tgtcat[0].Nmeasure = Nmeas;
     348  tgtcat[0].Nsecfilt_mem = Nave*Nsecfilt;
     349  if (VERBOSE) fprintf (stderr, "Nstars, Nave, Nmeas: "OFF_T_FMT" "OFF_T_FMT" "OFF_T_FMT", ("OFF_T_FMT" matches)\n",  Nstars,  Nave,  Nmeas,  Nmatch);
    297350
    298351  free (X1);
    … …  
    306359  return (Nmatch);
    307360}
     361
     362/** differences between find_matches_refstars.c and find_matches.c:
     363 * refstars has replace_match
     364 * refstars has TIMEREF and ACCEPT_MOTION
     365 * refstars does NOT have AddToCalibration
     366 * refstars does NOT have Nsec
     367 * refstars does NOT do update_coords
     368 **/

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

    r38636 r38986  
    131131
    132132    /** add starpar for this star **/
    133 
    134     // set the new starparments
    135     catalog[0].starpar[Nstarpar]          = stars[N].starpar;
    136     catalog[0].starpar[Nstarpar].averef   = n;
    137     catalog[0].starpar[Nstarpar].objID    = catalog[0].average[n].objID;
    138     catalog[0].starpar[Nstarpar].catID    = catID;
    139 
    140     // NOTE: include R,D in starpar?
    141     // XXX if I add R,D to starpar, I should rationalize R,D to the same boundary?
    142 
     133    off_t m;
     134    if (options->replace && catalog[0].average[n].Nstarpar) {
     135      m = catalog[0].average[n].starparOffset;
     136    } else {
     137      m = Nstarpar;
     138      catalog[0].average[n].starparOffset = m;
     139      catalog[0].average[n].Nstarpar ++;
     140      Nstarpar ++;
     141    }
     142    catalog[0].starpar[m]          = stars[N].starpar;
     143    catalog[0].starpar[m].averef   = n;
     144    catalog[0].starpar[m].objID    = catalog[0].average[n].objID;
     145    catalog[0].starpar[m].catID    = catID;
    143146    stars[N].found = TRUE;
    144     catalog[0].average[n].Nstarpar ++;
    145     Nstarpar ++;
    146147    i++;
    147148  }

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

    r34088 r38986  
    66// fill in the data for a JHK triplet star.  takes a pointer to the start of the line the
    77// RA and DEC have already been set
    8 int get2mass_3star_full (Stars **star, char *line, int Nmax) {
     8int get2mass_3star_full (Measure *measure, char *line, int Nmax) {
    99
    1010  char *ptr;
    … …  
    1717  ptr = next2MASSfield (ptr); // dec (assumed to be already set)
    1818  ptr = next2MASSfield (ptr); // err_maj
    19   star[0][0].measure.FWx = ToShortPixels(strtod (ptr, NULL));
     19  measure[0].FWx = ToShortPixels(strtod (ptr, NULL));
    2020  ptr = next2MASSfield (ptr); // err_min
    21   star[0][0].measure.FWy = ToShortPixels(strtod (ptr, NULL));
     21  measure[0].FWy = ToShortPixels(strtod (ptr, NULL));
    2222  ptr = next2MASSfield (ptr); // err_ang
    23   star[0][0].measure.theta = ToShortPixels(strtod (ptr, NULL));
    24 
    25   star[2][0].measure.FWx   = star[1][0].measure.FWx   = star[0][0].measure.FWx;
    26   star[2][0].measure.FWy   = star[1][0].measure.FWy   = star[0][0].measure.FWy;
    27   star[2][0].measure.theta = star[1][0].measure.theta = star[0][0].measure.theta;
     23  measure[0].theta = ToShortPixels(strtod (ptr, NULL));
     24
     25  measure[2].FWx   = measure[1].FWx   = measure[0].FWx;
     26  measure[2].FWy   = measure[1].FWy   = measure[0].FWy;
     27  measure[2].theta = measure[1].theta = measure[0].theta;
    2828
    2929  ptr = next2MASSfield (ptr); // designation (skip)
    3030
    3131  ptr = next2MASSfield (ptr); // j_m
    32   star[0][0].measure.M  = strtod (ptr, NULL);
     32  measure[0].M  = strtod (ptr, NULL);
    3333  ptr = next2MASSfield (ptr); // j_cmsig
    34   star[0][0].measure.dM = strtod (ptr, NULL);
     34  measure[0].dM = strtod (ptr, NULL);
    3535  ptr = next2MASSfield (ptr); // j_msigcom
    3636  dMfull = strtod (ptr, NULL);
    37   star[0][0].measure.dMcal = sqrt (SQ(dMfull) - SQ(star[0][0].measure.dM));
     37  measure[0].dMcal = sqrt (SQ(dMfull) - SQ(measure[0].dM));
    3838  ptr = next2MASSfield (ptr); // j_snr (skip)
    3939
    4040  ptr = next2MASSfield (ptr); // h_m
    41   star[1][0].measure.M  = strtod (ptr, NULL);
     41  measure[1].M  = strtod (ptr, NULL);
    4242  ptr = next2MASSfield (ptr); // h_cmsig
    43   star[1][0].measure.dM = strtod (ptr, NULL);
     43  measure[1].dM = strtod (ptr, NULL);
    4444  ptr = next2MASSfield (ptr); // h_msigcom
    4545  dMfull = strtod (ptr, NULL);
    46   star[1][0].measure.dMcal = sqrt (SQ(dMfull) - SQ(star[1][0].measure.dM));
     46  measure[1].dMcal = sqrt (SQ(dMfull) - SQ(measure[1].dM));
    4747  ptr = next2MASSfield (ptr); // h_snr (skip)
    4848
    4949  ptr = next2MASSfield (ptr); // k_m
    50   star[2][0].measure.M  = strtod (ptr, NULL);
     50  measure[2].M  = strtod (ptr, NULL);
    5151  ptr = next2MASSfield (ptr); // k_cmsig
    52   star[2][0].measure.dM = strtod (ptr, NULL);
     52  measure[2].dM = strtod (ptr, NULL);
    5353  ptr = next2MASSfield (ptr); // k_msigcom
    5454  dMfull = strtod (ptr, NULL);
    55   star[2][0].measure.dMcal = sqrt (SQ(dMfull) - SQ(star[2][0].measure.dM));
     55  measure[2].dMcal = sqrt (SQ(dMfull) - SQ(measure[2].dM));
    5656  ptr = next2MASSfield (ptr); // k_snr (skip)
    5757
    58   star[2][0].measure.photFlags = star[1][0].measure.photFlags = star[0][0].measure.photFlags = 0;
     58  measure[2].photFlags = measure[1].photFlags = measure[0].photFlags = 0;
    5959
    6060  ptr = next2MASSfield (ptr); // ph_qual
    61   set2MASS_ph_qual (star[0], ptr[0]);
    62   set2MASS_ph_qual (star[1], ptr[1]);
    63   set2MASS_ph_qual (star[2], ptr[2]);
     61  set2MASS_ph_qual (&measure[0], ptr[0]);
     62  set2MASS_ph_qual (&measure[1], ptr[1]);
     63  set2MASS_ph_qual (&measure[2], ptr[2]);
    6464
    6565  ptr = next2MASSfield (ptr); // rd_flg
    66   set2MASS_rd_flag (star[0], ptr[0]);
    67   set2MASS_rd_flag (star[1], ptr[1]);
    68   set2MASS_rd_flag (star[2], ptr[2]);
     66  set2MASS_rd_flag (&measure[0], ptr[0]);
     67  set2MASS_rd_flag (&measure[1], ptr[1]);
     68  set2MASS_rd_flag (&measure[2], ptr[2]);
    6969
    7070  ptr = next2MASSfield (ptr); // bl_flg
    71   set2MASS_bl_flag (star[0], ptr[0]);
    72   set2MASS_bl_flag (star[1], ptr[1]);
    73   set2MASS_bl_flag (star[2], ptr[2]);
     71  set2MASS_bl_flag (&measure[0], ptr[0]);
     72  set2MASS_bl_flag (&measure[1], ptr[1]);
     73  set2MASS_bl_flag (&measure[2], ptr[2]);
    7474
    7575  ptr = next2MASSfield (ptr); // cc_flg
    76   set2MASS_cc_flag (star[0], ptr[0]);
    77   set2MASS_cc_flag (star[1], ptr[1]);
    78   set2MASS_cc_flag (star[2], ptr[2]);
     76  set2MASS_cc_flag (&measure[0], ptr[0]);
     77  set2MASS_cc_flag (&measure[1], ptr[1]);
     78  set2MASS_cc_flag (&measure[2], ptr[2]);
    7979
    8080  ptr = next2MASSfield (ptr); // ndet (skip for now, XXX use somehow?)
    … …  
    8484
    8585  ptr = next2MASSfield (ptr); // gal_contam (one flag for all filters)
    86   set2MASS_gal_flag (star[0], ptr[0]);
    87   set2MASS_gal_flag (star[1], ptr[0]);
    88   set2MASS_gal_flag (star[2], ptr[0]);
     86  set2MASS_gal_flag (&measure[0], ptr[0]);
     87  set2MASS_gal_flag (&measure[1], ptr[0]);
     88  set2MASS_gal_flag (&measure[2], ptr[0]);
    8989
    9090  ptr = next2MASSfield (ptr); // mp_flg (one flag for all filters)
    91   set2MASS_mp_flag (star[0], ptr[0]);
    92   set2MASS_mp_flag (star[1], ptr[0]);
    93   set2MASS_mp_flag (star[2], ptr[0]);
     91  set2MASS_mp_flag (&measure[0], ptr[0]);
     92  set2MASS_mp_flag (&measure[1], ptr[0]);
     93  set2MASS_mp_flag (&measure[2], ptr[0]);
    9494
    9595  ptr = next2MASSfield (ptr); // pts_key (skip for now, XXX use somehow?)
    … …  
    101101
    102102  ptr = next2MASSfield (ptr); // x_scan
    103   star[0][0].measure.Xccd = strtod (ptr, NULL);
    104   star[2][0].measure.Xccd = star[1][0].measure.Xccd = star[0][0].measure.Xccd;
     103  measure[0].Xccd = strtod (ptr, NULL);
     104  measure[2].Xccd = measure[1].Xccd = measure[0].Xccd;
    105105
    106106  ptr = next2MASSfield (ptr); // jdate (julian date)
    107107  jd = strtod (ptr, NULL);
    108   star[0][0].measure.t = ohana_jd_to_sec (jd);
    109   star[2][0].measure.t = star[1][0].measure.t = star[0][0].measure.t;
     108  measure[0].t = ohana_jd_to_sec (jd);
     109  measure[2].t = measure[1].t = measure[0].t;
    110110
    111111  ptr = next2MASSfield (ptr); // j_psfchi
    112   star[0][0].measure.psfChisq = strtod (ptr, NULL);
     112  measure[0].psfChisq = strtod (ptr, NULL);
    113113  ptr = next2MASSfield (ptr); // h_psfchi
    114   star[1][0].measure.psfChisq = strtod (ptr, NULL);
     114  measure[1].psfChisq = strtod (ptr, NULL);
    115115  ptr = next2MASSfield (ptr); // k_psfchi
    116   star[2][0].measure.psfChisq = strtod (ptr, NULL);
     116  measure[2].psfChisq = strtod (ptr, NULL);
    117117
    118118  ptr = next2MASSfield (ptr); // j_m_stdap
    119   star[0][0].measure.Map = strtod (ptr, NULL);
     119  measure[0].Map = strtod (ptr, NULL);
    120120  ptr = next2MASSfield (ptr); // j_msig_stdap (skip?)
    121121
    122122  ptr = next2MASSfield (ptr); // h_m_stdap
    123   star[1][0].measure.Map = strtod (ptr, NULL);
     123  measure[1].Map = strtod (ptr, NULL);
    124124  ptr = next2MASSfield (ptr); // h_msig_stdap (skip?)
    125125
    126126  ptr = next2MASSfield (ptr); // k_m_stdap
    127   star[2][0].measure.Map = strtod (ptr, NULL);
     127  measure[2].Map = strtod (ptr, NULL);
    128128  ptr = next2MASSfield (ptr); // k_msig_stdap (skip?)
    129129
    … …  
    133133
    134134  ptr = next2MASSfield (ptr); // dup_src (one flag for all filters)
    135   set2MASS_dup_flag (star[0], ptr[0]);
    136   set2MASS_dup_flag (star[1], ptr[0]);
    137   set2MASS_dup_flag (star[2], ptr[0]);
     135  set2MASS_dup_flag (&measure[0], ptr[0]);
     136  set2MASS_dup_flag (&measure[1], ptr[0]);
     137  set2MASS_dup_flag (&measure[2], ptr[0]);
    138138
    139139  ptr = next2MASSfield (ptr); // use_src (one flag for all filters)
    140   set2MASS_use_flag (star[0], ptr[0]);
    141   set2MASS_use_flag (star[1], ptr[0]);
    142   set2MASS_use_flag (star[2], ptr[0]);
    143 
    144   star[0][0].measure.photcode  = TM_J;
    145   star[0][0].measure.detID   = 0;
    146   star[0][0].measure.imageID = 0;
    147 
    148   star[1][0].measure.photcode  = TM_H;
    149   star[1][0].measure.detID   = 0;
    150   star[1][0].measure.imageID = 0;
    151 
    152   star[2][0].measure.photcode  = TM_K;
    153   star[2][0].measure.detID   = 0;
    154   star[2][0].measure.imageID = 0;
     140  set2MASS_use_flag (&measure[0], ptr[0]);
     141  set2MASS_use_flag (&measure[1], ptr[0]);
     142  set2MASS_use_flag (&measure[2], ptr[0]);
     143
     144  measure[0].photcode  = TM_J;
     145  measure[0].detID   = 0;
     146  measure[0].imageID = 0;
     147
     148  measure[1].photcode  = TM_H;
     149  measure[1].detID   = 0;
     150  measure[1].imageID = 0;
     151
     152  measure[2].photcode  = TM_K;
     153  measure[2].detID   = 0;
     154  measure[2].imageID = 0;
    155155
    156156  return TRUE;
    … …  
    170170}
    171171
    172 int set2MASS_ph_qual (Stars *star, char qual) {
    173 
    174   switch (qual) {
    175     case 'A': star[0].measure.photFlags |= 0x00000001; break; // was: 0x0004
    176     case 'B': star[0].measure.photFlags |= 0x00000002; break; // was: 0x0005
    177     case 'C': star[0].measure.photFlags |= 0x00000004; break; // was: 0x0006
    178     case 'D': star[0].measure.photFlags |= 0x00000008; break; // was: 0x0007
    179     case 'E': star[0].measure.photFlags |= 0x00000010; break; // was: 0x0003
    180     case 'F': star[0].measure.photFlags |= 0x00000020; break; // was: 0x0002
    181     case 'U': star[0].measure.photFlags |= 0x00000040; break; // was: 0x0001
    182     case 'X': star[0].measure.photFlags |= 0x00000080; break; // was: 0x0000
     172int set2MASS_ph_qual (Measure *measure, char qual) {
     173
     174  switch (qual) {
     175    case 'A': measure[0].photFlags |= 0x00000001; break; // was: 0x0004
     176    case 'B': measure[0].photFlags |= 0x00000002; break; // was: 0x0005
     177    case 'C': measure[0].photFlags |= 0x00000004; break; // was: 0x0006
     178    case 'D': measure[0].photFlags |= 0x00000008; break; // was: 0x0007
     179    case 'E': measure[0].photFlags |= 0x00000010; break; // was: 0x0003
     180    case 'F': measure[0].photFlags |= 0x00000020; break; // was: 0x0002
     181    case 'U': measure[0].photFlags |= 0x00000040; break; // was: 0x0001
     182    case 'X': measure[0].photFlags |= 0x00000080; break; // was: 0x0000
    183183    default:
    184184      fprintf (stderr, "error!\n");
    … …  
    188188}
    189189
    190 int set2MASS_rd_flag (Stars *star, char qual) {
    191 
    192   switch (qual) {
    193     case '0': star[0].measure.photFlags |= 0x00000100; break; // was: 0x0000
    194     case '1': star[0].measure.photFlags |= 0x00000200; break; // was: 0x0010
    195     case '2': star[0].measure.photFlags |= 0x00000400; break; // was: 0x0020
    196     case '3': star[0].measure.photFlags |= 0x00000800; break; // was: 0x0030
    197     case '4': star[0].measure.photFlags |= 0x00001000; break; // was: 0x0040
    198     case '6': star[0].measure.photFlags |= 0x00002000; break; // was: 0x0050
    199     case '9': star[0].measure.photFlags |= 0x00004000; break; // was: 0x0060
     190int set2MASS_rd_flag (Measure *measure, char qual) {
     191
     192  switch (qual) {
     193    case '0': measure[0].photFlags |= 0x00000100; break; // was: 0x0000
     194    case '1': measure[0].photFlags |= 0x00000200; break; // was: 0x0010
     195    case '2': measure[0].photFlags |= 0x00000400; break; // was: 0x0020
     196    case '3': measure[0].photFlags |= 0x00000800; break; // was: 0x0030
     197    case '4': measure[0].photFlags |= 0x00001000; break; // was: 0x0040
     198    case '6': measure[0].photFlags |= 0x00002000; break; // was: 0x0050
     199    case '9': measure[0].photFlags |= 0x00004000; break; // was: 0x0060
    200200    default:
    201201      fprintf (stderr, "error!\n");
    … …  
    205205}
    206206
    207 int set2MASS_cc_flag (Stars *star, char qual) {
    208 
    209   switch (qual) {
    210     case 'p': star[0].measure.photFlags |= 0x00010000; break; // was: 0x0000
    211     case 'c': star[0].measure.photFlags |= 0x00020000; break; // was: 0x0100
    212     case 'd': star[0].measure.photFlags |= 0x00040000; break; // was: 0x0200
    213     case 's': star[0].measure.photFlags |= 0x00080000; break; // was: 0x0300
    214     case 'b': star[0].measure.photFlags |= 0x00010000; break; // was: 0x0400
    215     case '0': star[0].measure.photFlags |= 0x00020000; break; // was: 0x0500
     207int set2MASS_cc_flag (Measure *measure, char qual) {
     208
     209  switch (qual) {
     210    case 'p': measure[0].photFlags |= 0x00010000; break; // was: 0x0000
     211    case 'c': measure[0].photFlags |= 0x00020000; break; // was: 0x0100
     212    case 'd': measure[0].photFlags |= 0x00040000; break; // was: 0x0200
     213    case 's': measure[0].photFlags |= 0x00080000; break; // was: 0x0300
     214    case 'b': measure[0].photFlags |= 0x00010000; break; // was: 0x0400
     215    case '0': measure[0].photFlags |= 0x00020000; break; // was: 0x0500
    216216    default:
    217217      fprintf (stderr, "error!\n");
    … …  
    221221}
    222222
    223 int set2MASS_bl_flag (Stars *star, char qual) {
    224 
    225   switch (qual) {
    226     case '0': star[0].measure.photFlags &= ~0x00300000; break; // was: ~0x0008
    227     case '1': star[0].measure.photFlags |=  0x00100000; break; // was: ~0x0008
    228     default:  star[0].measure.photFlags |=  0x00200000; break; // was:  0x0008
    229   }     
    230   return (TRUE);
    231 }
    232 
    233 int set2MASS_gal_flag (Stars *star, char qual) {
    234 
    235   switch (qual) {
    236     case '0': star[0].measure.photFlags &= ~0x00c00000; break; // was: ~0x0080
    237     case '1': star[0].measure.photFlags |=  0x00400000; break; // was: ~0x0080
    238     default:  star[0].measure.photFlags |=  0x00800000;        // was:  0x0080
    239       star[0].measure.extNsigma = 100.0;
     223int set2MASS_bl_flag (Measure *measure, char qual) {
     224
     225  switch (qual) {
     226    case '0': measure[0].photFlags &= ~0x00300000; break; // was: ~0x0008
     227    case '1': measure[0].photFlags |=  0x00100000; break; // was: ~0x0008
     228    default:  measure[0].photFlags |=  0x00200000; break; // was:  0x0008
     229  }     
     230  return (TRUE);
     231}
     232
     233int set2MASS_gal_flag (Measure *measure, char qual) {
     234
     235  switch (qual) {
     236    case '0': measure[0].photFlags &= ~0x00c00000; break; // was: ~0x0080
     237    case '1': measure[0].photFlags |=  0x00400000; break; // was: ~0x0080
     238    default:  measure[0].photFlags |=  0x00800000;             // was:  0x0080
     239      measure[0].extNsigma = 100.0;
    240240      break;
    241241  }     
    … …  
    243243}
    244244
    245 int set2MASS_mp_flag (Stars *star, char qual) {
    246 
    247   switch (qual) {
    248     case '0': star[0].measure.photFlags &= ~0x03000000; break; // was: ~0x0800
    249     case '1': star[0].measure.photFlags |=  0x01000000; break; // was: ~0x0800
    250     default:  star[0].measure.photFlags |=  0x02000000; break; // was:  0x0800
    251   }     
    252   return (TRUE);
    253 }
    254 
    255 int set2MASS_dup_flag (Stars *star, char qual) {
    256 
    257   switch (qual) {
    258     case '0': star[0].measure.photFlags &= ~0x0c000000; break; // was: ~0x1000
    259     case '1': star[0].measure.photFlags |=  0x04000000; break; // was: ~0x1000
    260     default:  star[0].measure.photFlags |=  0x08000000; break; // was:  0x1000
    261   }     
    262   return (TRUE);
    263 }
    264 
    265 int set2MASS_use_flag (Stars *star, char qual) {
    266 
    267   switch (qual) {
    268     case '0': star[0].measure.photFlags &= ~0x10000000; break; // was: ~0x2000
    269     case '1': star[0].measure.photFlags |=  0x10000000; break; // was:  0x2000
     245int set2MASS_mp_flag (Measure *measure, char qual) {
     246
     247  switch (qual) {
     248    case '0': measure[0].photFlags &= ~0x03000000; break; // was: ~0x0800
     249    case '1': measure[0].photFlags |=  0x01000000; break; // was: ~0x0800
     250    default:  measure[0].photFlags |=  0x02000000; break; // was:  0x0800
     251  }     
     252  return (TRUE);
     253}
     254
     255int set2MASS_dup_flag (Measure *measure, char qual) {
     256
     257  switch (qual) {
     258    case '0': measure[0].photFlags &= ~0x0c000000; break; // was: ~0x1000
     259    case '1': measure[0].photFlags |=  0x04000000; break; // was: ~0x1000
     260    default:  measure[0].photFlags |=  0x08000000; break; // was:  0x1000
     261  }     
     262  return (TRUE);
     263}
     264
     265int set2MASS_use_flag (Measure *measure, char qual) {
     266
     267  switch (qual) {
     268    case '0': measure[0].photFlags &= ~0x10000000; break; // was: ~0x2000
     269    case '1': measure[0].photFlags |=  0x10000000; break; // was:  0x2000
    270270    default:  abort();
    271271  }     

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

    r34088 r38986  
    3636}
    3737
     38# if (0)
    3839// fill in the data for a single star.  takes a pointer to the start of the line
    3940int get2mass_star (Stars *star, char *line, int Nmax) {
    … …  
    136137  return TRUE;
    137138}
     139# endif
    138140
    139141// fill in the coords for a single star.  takes a pointer to the start of the line

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

    r38467 r38986  
    44# define DNSTARS 1000
    55
    6 static short GSC_M;
    76static SkyTable *sky = NULL;
    87
    9 Stars *getgsc (SkyRegion *patch, unsigned int *NSTARS) {
     8static short int GSC_M;
     9
     10Catalog *getgsc (SkyRegion *patch) {
    1011 
    11   unsigned int i, Ngsc, Nstars;
    12   Stars *gsc;
    13   Stars *stars;
     12  unsigned int i;
    1413  SkyList *skylist;
    1514
    … …  
    2322  skylist = SkyListByPatch (sky, -1, patch);
    2423 
    25   Nstars = 0;
    26   ALLOCATE (stars, Stars, 1);
    27  
     24  Catalog *catalog = NULL;
     25  ALLOCATE (catalog, Catalog, 1);
     26  dvo_catalog_init (catalog, TRUE);
     27  ALLOCATE (catalog->average, Average, 1);
     28  ALLOCATE (catalog->measure, Measure, 1);
     29  ALLOCATE (catalog->lensing, Lensing, 1);
     30
     31  SkyRegion region;
     32  region.Rmin =   0.0;
     33  region.Rmax = 360.0;
     34  region.Dmin = -90.0;
     35  region.Dmax = +90.0;
     36
    2837  for (i = 0; i < skylist[0].Nregions; i++) {
    29     gsc = rd_gsc (skylist[0].filename[i], &Ngsc);
     38    Catalog *newcat = rd_gsc (skylist[0].filename[i]);
    3039
    31     REALLOCATE (stars, Stars, MAX (1, Nstars + Ngsc));
    32     memcpy (&stars[Nstars], gsc, Ngsc*sizeof(Stars));
    33     Nstars += Ngsc;
    34 
    35     free (gsc);
     40    AddstarClientOptions matchOptions;
     41    matchOptions.radius = 0.4; // tight radius at this stage
     42    matchOptions.calibrate = FALSE;
     43    matchOptions.only_match = FALSE;
     44    matchOptions.nosort = FALSE;
     45    matchOptions.photcode = 0; // use an invalid photcode to avoid touching secfilt
     46   
     47    find_matches_closest (&region, newcat, catalog, matchOptions);
     48   
     49    if (newcat) {
     50      dvo_catalog_free (newcat);
     51      free (newcat);
     52    }
    3653  }
    3754 
    38   // XXX don't free because we only load it once and save it
    3955  SkyListFree (skylist);
    40   // SkyTableFree (sky);
    4156
    42   if (VERBOSE) fprintf (stderr, "%d stars from HST GSC\n", Nstars);
    43   *NSTARS = Nstars;
    44   return (stars);
     57  if (VERBOSE) fprintf (stderr, "%d stars from HST GSC\n", (int) catalog->Naverage);
     58  return (catalog);
    4559} 
    4660
    47 Stars *rd_gsc (char *filename, unsigned int *nstars) {
     61Catalog *rd_gsc (char *filename) {
    4862 
    49   int i, NSTARS, Nstars, Nbytes, nbytes, Nline, Nbyte;
     63  int i, Nbytes, nbytes, Nline, Nbyte;
    5064  char *buffer;
    5165  FILE *f;
    52   Stars *stars;
    5366
    54   Nstars = 0;
    55   NSTARS = 1000;
    56   ALLOCATE (stars, Stars, NSTARS);
     67  int Nave = 0;
     68  int Nmeas = 0;
     69  int NAVE = 1000;
     70  int NMEAS = 1000;
     71
     72  Catalog *catalog = NULL;
     73  ALLOCATE (catalog, Catalog, 1);
     74  dvo_catalog_init (catalog, TRUE);
     75  ALLOCATE (catalog->average, Average, NAVE);
     76  ALLOCATE (catalog->measure, Measure, NMEAS);
    5777
    5878  f = fopen (filename, "r");
    … …  
    6888    for (i = 0; i < Nline; i++) {
    6989
    70       InitStar (&stars[Nstars]);
     90      dvo_average_init (&catalog->average[Nave]);
     91      dvo_measure_init (&catalog->measure[Nmeas]);
    7192
    7293      Nbyte = i*BYTES_STAR;
    73       dparse (&stars[Nstars].average.R, 1, &buffer[Nbyte]);
    74       dparse (&stars[Nstars].average.D, 2, &buffer[Nbyte]);
     94      dparse (&catalog->average[Nave].R, 1, &buffer[Nbyte]);
     95      dparse (&catalog->average[Nave].D, 2, &buffer[Nbyte]);
    7596
    76       if (stars[Nstars].average.R < UserPatch.Rmin) continue;
    77       if (stars[Nstars].average.R > UserPatch.Rmax) continue;
    78       if (stars[Nstars].average.D < UserPatch.Dmin) continue;
    79       if (stars[Nstars].average.D > UserPatch.Dmax) continue;
     97      if (catalog->average[Nave].R < UserPatch.Rmin) continue;
     98      if (catalog->average[Nave].R > UserPatch.Rmax) continue;
     99      if (catalog->average[Nave].D < UserPatch.Dmin) continue;
     100      if (catalog->average[Nave].D > UserPatch.Dmax) continue;
    80101
    81       stars[Nstars].measure.R = stars[Nstars].average.R;
    82       stars[Nstars].measure.D = stars[Nstars].average.D;
     102      catalog->measure[Nmeas].R = catalog->average[Nave].R;
     103      catalog->measure[Nmeas].D = catalog->average[Nave].D;
    83104
    84       fparse (&stars[Nstars].measure.M, 3, &buffer[Nbyte]);
    85       stars[Nstars].measure.dM        = NAN;
    86       stars[Nstars].measure.photcode = GSC_M;
    87       stars[Nstars].measure.t        = 0;
     105      fparse (&catalog->measure[Nmeas].M, 3, &buffer[Nbyte]);
     106      catalog->measure[Nmeas].dM = NAN;
     107      catalog->measure[Nmeas].photcode = GSC_M;
     108      catalog->measure[Nmeas].t = 0;
    88109
    89       Nstars ++;
    90       CHECK_REALLOCATE (stars, Stars, NSTARS, Nstars, 1000);
     110      catalog->average[Nave].Nmeasure = 1;
     111      catalog->average[Nave].measureOffset = Nmeas;
     112
     113      Nave ++;
     114      Nmeas ++;
     115
     116      CHECK_REALLOCATE (catalog->average, Average, NAVE,  Nave,  1000);
     117      CHECK_REALLOCATE (catalog->measure, Measure, NMEAS, Nmeas, 1000);
    91118    }
    92119  }
    93120  fclose (f);
    94121  free (buffer);
    95   REALLOCATE (stars, Stars, Nstars);
    96   *nstars = Nstars;
    97   return (stars);
     122  return (catalog);
    98123}

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

    r38467 r38986  
    44# define NELEM  3
    55
    6 Stars *getusno (SkyRegion *catstats, int photcode, unsigned int *nstars) {
     6Catalog *getusno (SkyRegion *catstats) {
    77
    88  off_t offset;
    … …  
    1515  double dec;
    1616  int spd, spd_start, spd_end;
    17   int NUSNO, Nusno;
    18   Stars *stars;
    1917  short int USNO_RED, USNO_BLUE;
    2018
    … …  
    2220  NAMED_PHOTCODE (USNO_RED, "USNO_RED");
    2321  NAMED_PHOTCODE (USNO_BLUE, "USNO_BLUE");
    24   if (photcode == USNO_RED) goto good_code;
    25   if (photcode == USNO_BLUE) goto good_code;
    26   Shutdown ("USNO photcode not specified");
    27 good_code:
    2822
    2923  /* identify ra & dec range of interest */
    … …  
    4337  }
    4438
    45   Nusno = 0;
    46   NUSNO = 5000;
    47   ALLOCATE (stars, Stars, NUSNO);
     39  int Nave = 0;
     40  int Nmeas = 0;
     41  int NAVE = 1000;
     42  int NMEAS = 1000;
     43
     44  Catalog *catalog = NULL;
     45  ALLOCATE (catalog, Catalog, 1);
     46  dvo_catalog_init (catalog, TRUE);
     47  ALLOCATE (catalog->average, Average, NAVE);
     48  ALLOCATE (catalog->measure, Measure, NMEAS);
    4849
    4950  for (spd = spd_start; spd < spd_end; spd += 75) {
    … …  
    110111      if (buf[1] > iDEC1) continue;
    111112
    112       InitStar (&stars[Nusno]);
     113      dvo_average_init (&catalog->average[Nave]);
     114      dvo_measure_init (&catalog->measure[Nmeas+0]);
     115      dvo_measure_init (&catalog->measure[Nmeas+1]);
    113116
    114       stars[Nusno].average.R     = buf[0]/360000.0;
    115       stars[Nusno].average.D     = buf[1]/360000.0 - 90.0;
    116       stars[Nusno].measure.R     = stars[Nusno].average.R;
    117       stars[Nusno].measure.D     = stars[Nusno].average.D;
    118       stars[Nusno].measure.dM    = NAN;
     117      catalog->average[Nave].R     = buf[0]/360000.0;
     118      catalog->average[Nave].D     = buf[1]/360000.0 - 90.0;
    119119
    120       /* one pass of addstar does either r or b */
    121       if (photcode == USNO_RED) {
    122         stars[Nusno].measure.photcode = USNO_RED;
    123         stars[Nusno].measure.M        = fabs (0.1*(buf[2] - 1000*((int)(buf[2]/1000))));
    124       }
    125       if (photcode == USNO_BLUE) {     
    126         stars[Nusno].measure.photcode = USNO_BLUE;
    127         stars[Nusno].measure.M        = fabs (0.1*((int)(buf[2] - 1000000*((int)(buf[2]/1000000))) / 1000));
    128       }
    129       Nusno ++;
    130       CHECK_REALLOCATE (stars, Stars, NUSNO, Nusno, 5000);
     120      catalog->measure[Nmeas+0].R  = catalog->average[Nave].R;
     121      catalog->measure[Nmeas+0].D  = catalog->average[Nave].D;
     122      catalog->measure[Nmeas+0].dM = NAN;
     123      catalog->measure[Nmeas+1].R  = catalog->average[Nave].R;
     124      catalog->measure[Nmeas+1].D  = catalog->average[Nave].D;
     125      catalog->measure[Nmeas+1].dM = NAN;
     126
     127      catalog->measure[Nmeas+0].photcode = USNO_RED;
     128      catalog->measure[Nmeas+0].M        = fabs (0.1*(buf[2] - 1000*((int)(buf[2]/1000))));
     129      catalog->measure[Nmeas+1].photcode = USNO_BLUE;
     130      catalog->measure[Nmeas+1].M        = fabs (0.1*((int)(buf[2] - 1000000*((int)(buf[2]/1000000))) / 1000));
     131
     132      catalog->average[Nave].Nmeasure = 2;
     133      catalog->average[Nave].measureOffset = Nmeas;
     134
     135      Nave ++;
     136      Nmeas += 2;
     137
     138      CHECK_REALLOCATE (catalog->average, Average, NAVE,  Nave,  1000);
     139      CHECK_REALLOCATE (catalog->measure, Measure, NMEAS, Nmeas, 1000);
    131140    }
    132141    free (buffer);
    133142    fclose (f);
    134143  }
    135   REALLOCATE (stars, Stars, Nusno);
     144  catalog->Naverage = Nave;
     145  catalog->Nmeasure = Nmeas;
    136146
    137   *nstars = Nusno;
    138   if (VERBOSE) fprintf (stderr, "%d stars from USNO 1.0\n", Nusno);
    139   return (stars);
     147  if (VERBOSE) fprintf (stderr, "%d stars from USNO 1.0\n", Nave);
     148  return (catalog);
    140149}
    141150

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

    r38467 r38986  
    33# define NELEM  20
    44
    5 Stars *getusnob (SkyRegion *catstats, int photcode, unsigned int *nstars) {
     5Catalog *getusnob (SkyRegion *catstats) {
    66
    77  off_t offset;
    8   int i, bin, first, last, nitems, Nitems, Nbins, Nitemsum;
     8  int i, j, bin, first, last, nitems, Nitems, Nbins, Nitemsum;
    99  float hours[100];
    1010  int start[100], number[100], *buffer, *buf;
    … …  
    1515  int iDEC0, iDEC1, iRA0, iRA1;
    1616  int spd, spd_start, spd_end;
    17   int NUSNO, Nusno, Nstars;
    1817  short int USNO_RED, USNO_BLUE, USNO_N;
    1918  e_time USNOepoch;
    20   Stars *stars;
    2119
    2220  m1 = m2 = 0.0;
    … …  
    2624  NAMED_PHOTCODE (USNO_BLUE, "USNO_BLUE");
    2725  NAMED_PHOTCODE (USNO_N,    "USNO_N");
    28   if (photcode == USNO_RED)  goto good_code;
    29   if (photcode == USNO_BLUE) goto good_code;
    30   if (photcode == USNO_N)    goto good_code;
    31   Shutdown ("USNO photcode not specified");
    32 good_code:
    3326
    3427  fprintf (stderr, "loading USNO-B 1.0\n");
    … …  
    5245
    5346  Nitemsum = 0;
    54   Nusno = 0;
    55   NUSNO = 5000;
    56   ALLOCATE (stars, Stars, NUSNO);
     47
     48  int Nave = 0;
     49  int Nmeas = 0;
     50  int NAVE = 1000;
     51  int NMEAS = 1000;
     52
     53  Catalog *catalog = NULL;
     54  ALLOCATE (catalog, Catalog, 1);
     55  dvo_catalog_init (catalog, TRUE);
     56  ALLOCATE (catalog->average, Average, NAVE);
     57  ALLOCATE (catalog->measure, Measure, NMEAS);
    5758
    5859  for (spd = spd_start; spd < spd_end; spd ++) {
    … …  
    9697
    9798    /* sum the number of stars in data segment of interest */
    98     Nstars = 0;
     99    int Nstars = 0;
    99100    for (bin = first; bin < last; bin++) {
    100101      Nstars += number[bin];
    … …  
    125126      /* USNO coords are reported for J2000 / epoch 2000.0 */
    126127      /* extract the basic stellar data */
    127       InitStar (&stars[Nusno]);
     128      dvo_average_init (&catalog->average[Nave]);
     129      dvo_measure_init (&catalog->measure[Nmeas+0]);
     130      dvo_measure_init (&catalog->measure[Nmeas+1]);
    128131
    129       stars[Nusno].average.R   = buf[0]/360000.0;
    130       stars[Nusno].average.D   = buf[1]/360000.0 - 90.0;
     132      catalog->average[Nave].R   = buf[0]/360000.0;
     133      catalog->average[Nave].D   = buf[1]/360000.0 - 90.0;
    131134
    132135      /* XXX uR cos(D) or just uR ??? */
    133       stars[Nusno].average.uR  = 2.0 * ((buf[2]       % 10000) - 5000);
    134       stars[Nusno].average.uD  = 2.0 * ((buf[2]/10000 % 10000) - 5000);
     136      catalog->average[Nave].uR  = 2.0 * ((buf[2]       % 10000) - 5000);
     137      catalog->average[Nave].uD  = 2.0 * ((buf[2]/10000 % 10000) - 5000);
    135138
    136       stars[Nusno].average.duR = (buf[3]      % 1000);
    137       stars[Nusno].average.duD = (buf[3]/1000 % 1000);
    138 
    139       stars[Nusno].average.dR  = 0.001 * (buf[4]      % 1000);
    140       stars[Nusno].average.dD  = 0.001 * (buf[4]/1000 % 1000);
    141 
    142       stars[Nusno].average.P   = 0;
    143       stars[Nusno].average.dP  = 0;
    144 
    145       stars[Nusno].measure.R   = stars[Nusno].average.R;
    146       stars[Nusno].measure.D   = stars[Nusno].average.D;
    147 
    148       /* USNO magnitude errors are reported as a fixed 0.3 mag */
    149       stars[Nusno].measure.dM  = 0.3;
     139      catalog->average[Nave].duR = (buf[3]      % 1000);
     140      catalog->average[Nave].duD = (buf[3]/1000 % 1000);
     141      catalog->average[Nave].dR  = 0.001 * (buf[4]      % 1000);
     142      catalog->average[Nave].dD  = 0.001 * (buf[4]/1000 % 1000);
     143      catalog->average[Nave].P   = 0;
     144      catalog->average[Nave].dP  = 0;
    150145
    151146      /* USNO-B uses J2000 equinox and 2000.0 epoch for coordinates */
    152147      /* the magnitudes have no temporal information */
    153       stars[Nusno].measure.t   = USNOepoch;
    154148
    155       /* one pass of addstar does r, b, or n */
    156       if (photcode == USNO_BLUE) {
    157           m1 = fabs(0.01 * (buf[5] % 10000)); /* 1st blue mag */
    158           m2 = fabs(0.01 * (buf[7] % 10000)); /* 1st blue mag */
     149      for (j = 0; j < 3; j++) {
     150        catalog->measure[Nmeas+j].R  = catalog->average[Nave].R;
     151        catalog->measure[Nmeas+j].D  = catalog->average[Nave].D;
     152        catalog->measure[Nmeas+j].dM = 0.3; /* USNO magnitude errors are reported as a fixed 0.3 mag */
     153        catalog->measure[Nmeas+j].t  = USNOepoch;
    159154      }
    160       if (photcode == USNO_RED) {
    161           m1 = fabs(0.01 * (buf[6] % 10000)); /* 1st red mag */
    162           m2 = fabs(0.01 * (buf[8] % 10000)); /* 2nd red mag */
    163       }
    164       if (photcode == USNO_N) {
    165           m1 = fabs(0.01 * (buf[9] % 10000)); /* N (IR) survey */
    166           m2 = 0;
    167       }
    168       stars[Nusno].measure.photcode = photcode;
    169155
    170       /* if two mags are available, get an average */
     156      catalog->measure[Nmeas+0].photcode = USNO_BLUE;
     157      m1 = fabs(0.01 * (buf[5] % 10000)); /* 1st blue mag */
     158      m2 = fabs(0.01 * (buf[7] % 10000)); /* 2nd blue mag */
    171159      if (m1 && m2) {
    172160        mag = 0.5*(m1 + m2);
    … …  
    174162        mag = (m1) ? m1 : m2;
    175163      }
    176       stars[Nusno].measure.M = (mag == 0.0) ? 32.0 : mag;
     164      catalog->measure[Nmeas+0].M = (mag == 0.0) ? 32.0 : mag;
    177165
    178       Nusno ++;
    179       CHECK_REALLOCATE (stars, Stars, NUSNO, Nusno, 5000);
     166      catalog->measure[Nmeas+1].photcode = USNO_RED;
     167      m1 = fabs(0.01 * (buf[6] % 10000)); /* 1st red mag */
     168      m2 = fabs(0.01 * (buf[8] % 10000)); /* 2nd red mag */
     169      if (m1 && m2) {
     170        mag = 0.5*(m1 + m2);
     171      } else {
     172        mag = (m1) ? m1 : m2;
     173      }
     174      catalog->measure[Nmeas+1].M = (mag == 0.0) ? 32.0 : mag;
     175     
     176      catalog->measure[Nmeas+2].photcode = USNO_N;
     177      catalog->measure[Nmeas+2].M = fabs(0.01 * (buf[9] % 10000)); /* N (IR) survey */
     178
     179      catalog->average[Nave].Nmeasure = 3;
     180      catalog->average[Nave].measureOffset = Nmeas;
     181
     182      Nave ++;
     183      Nmeas += 3;
     184
     185      CHECK_REALLOCATE (catalog->average, Average, NAVE,  Nave,  1000);
     186      CHECK_REALLOCATE (catalog->measure, Measure, NMEAS, Nmeas, 1000);
    180187    }
    181188    free (buffer);
    182189    Nitemsum += Nitems;
    183     if (VERBOSE) fprintf (stderr, "Nusno: %d, Nitems: %d, Nitemsum : %d, Nbytes stars: %d\n", Nusno, Nitems, Nitemsum, (unsigned int) (Nusno*sizeof(Stars)));
     190    if (VERBOSE) fprintf (stderr, "Naverage: %d, Nitems: %d, Nitemsum : %d\n", Nave, Nitems, Nitemsum);
    184191    fclose (f);
    185192  }
     193  catalog->Naverage = Nave;
     194  catalog->Nmeasure = Nmeas;
    186195
    187   REALLOCATE (stars, Stars, MAX (1, Nusno));
    188 
    189   *nstars = Nusno;
    190   if (VERBOSE) fprintf (stderr, "%d stars from USNO-B 1.0\n", Nusno);
    191   return (stars);
     196  if (VERBOSE) fprintf (stderr, "%d stars from USNO-B 1.0\n", Nave);
     197  return (catalog);
    192198}

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

    r38467 r38986  
    33# define LOAD_DR2    1
    44
    5 Stars *greference (char *Refcat, SkyRegion *region, int photcode, unsigned int *nstars) {
     5Catalog *greference (char *Refcat, SkyRegion *region, int photcode) {
    66
    7   unsigned int Nstars;
    8   Stars *stars;
     7  Catalog *catalog = NULL;
    98
    109  if (VERBOSE) fprintf (stderr, "loading reference catalog data from %s\n", Refcat);
    1110  if (VERBOSE) fprintf (stderr, "full region: %f - %f, %f - %f\n", region[0].Rmin, region[0].Rmax, region[0].Dmin, region[0].Dmax);
    1211
    13   Nstars = 0;
    14   stars = NULL;
    15 
     12  /* get stars from HST GSC for the given region */
     13  if (!strcasecmp (Refcat, "GSC")) {
     14    catalog = getgsc (region);
     15  }
     16 
    1617  /* get stars from USNO for the given region */
    1718  if (!strcasecmp (Refcat, "USNO")) {
    18     stars = getusno (region, photcode, &Nstars);
     19    catalog = getusno (region);
    1920  }
    2021
    2122  /* get stars from the USNO B catalog for the given region */
    2223  if (!strcasecmp (Refcat, "USNOB")) {
    23     stars = getusnob (region, photcode, &Nstars);
     24    catalog = getusnob (region);
    2425  }
    2526
    2627  /* get stars from the Tycho catalog for the given region */
    2728  if (!strcasecmp (Refcat, "TYCHO")) {
    28     // stars = gettycho2 (region, photcode, &Nstars);
    2929    fprintf (stderr, "Tycho load via addstar is deprecated: use loadtycho\n");
    3030    exit (2);
    … …  
    3333  /* get stars from the Tycho catalog for the given region (old ingest) */
    3434  if (!strcasecmp (Refcat, "TYCHO_OLD")) {
    35     // stars = gettycho (region, photcode, &Nstars);
    3635    fprintf (stderr, "Tycho load via addstar is deprecated: use loadtycho\n");
    3736    exit (2);
    3837  }
    3938
    40   /* get stars from HST GSC for the given region */
    41   if (!strcasecmp (Refcat, "GSC")) {
    42     stars = getgsc (region, &Nstars);
    43   }
    44  
    4539  /* get stars from 2MASS for the given region */
    4640  if (!strcasecmp (Refcat, "2MASS")) {
    47     // stars = get2mass (region, photcode, LOAD_ALLSKY, &Nstars);
    4841    fprintf (stderr, "2MASS load via addstar is deprecated: use load2mass\n");
    4942    exit (2);
    … …  
    5245  /* get stars from 2MASS for the given region */
    5346  if (!strcasecmp (Refcat, "2MASS-ALLSKY")) {
    54     // stars = get2mass (region, photcode, LOAD_ALLSKY, &Nstars);
    5547    fprintf (stderr, "2MASS load via addstar is deprecated: use load2mass\n");
    5648    exit (2);
    … …  
    5951  /* get stars from 2MASS for the given region */
    6052  if (!strcasecmp (Refcat, "2MASS-DR2")) {
    61     // stars = get2mass (region, photcode, LOAD_DR2, &Nstars);
    6253    fprintf (stderr, "2MASS load via addstar is deprecated: use load2mass\n");
    6354    exit (2);
    6455  }
    6556 
    66   if (VERBOSE && (Nstars == 0)) fprintf (stderr, "no ref objects in region %s\n", region[0].name);
     57  if (VERBOSE && (catalog->Naverage == 0)) fprintf (stderr, "no ref objects in region %s\n", region[0].name);
    6758
    68   *nstars = Nstars;
    69   return (stars);
    70 
     59  return (catalog);
    7160}

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

    r38467 r38986  
    22
    33/* read ASCII file with ref star data */
    4 Stars *grefstars (char *file, int photcode, unsigned int *Nstars) {
     4Catalog *grefstars (char *file, int photcode) {
    55
    66  FILE *f;
    7   int N, NSTARS;
    8   Stars *stars;
     7  int NSTARS;
    98  char line[256];
    109
    … …  
    1312  if (f == NULL) Shutdown ("can't read data from %s", file);
    1413
    15   NSTARS = 100;
    16   ALLOCATE (stars, Stars, NSTARS);
     14  NSTARS = 1000;
     15
     16  Catalog *catalog = NULL;
     17  ALLOCATE (catalog, Catalog, 1);
     18  dvo_catalog_init (catalog, TRUE);
     19  ALLOCATE (catalog->average, Average, NSTARS);
     20  ALLOCATE (catalog->measure, Measure, NSTARS);
    1721
    1822  /* read in stars line-by-line */
    19   for (N = 0; scan_line (f, line) != EOF; N++) {
     23  int N = 0;
     24  while (scan_line (f, line) != EOF) {
    2025    stripwhite (line);
    2126    if (line[0] == 0) continue;
    2227    if (line[0] == '#') continue;
    2328
    24     InitStar (&stars[N]);
     29    dvo_average_init (&catalog->average[N]);
     30    dvo_measure_init (&catalog->measure[N]);
    2531
    2632    int status = sscanf (line, "%lf %lf %f %f %x",
    27                      &stars[N].average.R,  &stars[N].average.D, 
    28                      &stars[N].measure.M, &stars[N].measure.dM,
    29                      &stars[N].measure.photFlags);
     33                         &catalog->average[N].R, &catalog->average[N].D, 
     34                         &catalog->measure[N].M, &catalog->measure[N].dM,
     35                         &catalog->measure[N].photFlags);
     36
    3037    if ((status != 4) && (status != 5)) {
    3138      fprintf (stderr, "error reading line: %s\n", line);
    32       N --;
    3339      continue;
    3440    }
    35     stars[N].average.R = ohana_normalize_angle (stars[N].average.R);
     41    catalog->average[N].R = ohana_normalize_angle (catalog->average[N].R);
    3642
    37     stars[N].measure.R = stars[N].average.R;
    38     stars[N].measure.D = stars[N].average.D;
     43    catalog->measure[N].R = catalog->average[N].R;
     44    catalog->measure[N].D = catalog->average[N].D;
    3945
    40     stars[N].measure.photcode = photcode;
     46    catalog->measure[N].photcode = photcode;
    4147
    42     CHECK_REALLOCATE (stars, Stars, NSTARS, N+1, 100);
     48    catalog->average[N].Nmeasure = 1;
     49    catalog->average[N].measureOffset = N;
     50
     51    N++;
     52    CHECK_REALLOCATE (catalog->average, Average, NSTARS, N, 1000);
     53    CHECK_REALLOCATE (catalog->measure, Measure, NSTARS, N, 1000);
    4354  }
    44   *Nstars = N;
    45   return (stars);
     55  catalog->Naverage = N;
     56  catalog->Nmeasure = N;
     57  return (catalog);
    4658}

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

    r25757 r38986  
    1212
    1313  // need to construct these options with args_load2mass...
     14  SetSignals ();
    1415  options = ConfigInit (&argc, argv);
    1516  options = args_load2mass (argc, argv, options);

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

    r38471 r38986  
    1212int load2mass_as_rawdata (SkyList *skytable, char *filename, AddstarClientOptions options) {
    1313 
    14   int i, j, verbose;
    15   int Nstars, NSTARS, Ntstars, NTSTARS;
     14  int i, j, k, verbose;
     15  int Ntstars, NTSTARS;
    1616  int Nbyte, Nextra, offset;
    1717
    … …  
    2121  char *buffer, *p, *q;
    2222
    23   Stars **stars; // this is an array of pointers to be consistent with input to find_match_refstars
    2423  TMStars *tstars;
    2524  SkyList *skylist;
    … …  
    117116      if (DEBUG) fprintf (stderr, "writing to %s\n", skylist[0].filename[0]);
    118117
    119       // collect array of (Stars *) stars in a new output catalog
    120       Nstars = 0;
    121       NSTARS = 3000;
    122       ALLOCATE (stars, Stars *, NSTARS);
     118      int Nave = 0;
     119      int Nmeas = 0;
     120      int NAVE = 1000;
     121      int NMEAS = 3000;
     122
     123      Catalog *newcat = NULL;
     124      ALLOCATE (newcat, Catalog, 1);
     125      dvo_catalog_init (newcat, TRUE);
     126      ALLOCATE (newcat->average, Average, NAVE);
     127      ALLOCATE (newcat->measure, Measure, NMEAS);
    123128
    124129      // loop over stars in this 2mass region that are also in this output region
    … …  
    140145        offset = tstars[j].offset;
    141146
    142         ALLOCATE (stars[Nstars+0], Stars, 1);
    143         ALLOCATE (stars[Nstars+1], Stars, 1);
    144         ALLOCATE (stars[Nstars+2], Stars, 1);
    145 
    146         InitStar (stars[Nstars+0]);
    147         InitStar (stars[Nstars+1]);
    148         InitStar (stars[Nstars+2]);
    149 
    150         stars[Nstars+0][0].average.R = tstars[j].R;
    151         stars[Nstars+0][0].average.D = tstars[j].D;
    152         stars[Nstars+1][0].average.R = tstars[j].R;
    153         stars[Nstars+1][0].average.D = tstars[j].D;
    154         stars[Nstars+2][0].average.R = tstars[j].R;
    155         stars[Nstars+2][0].average.D = tstars[j].D;
    156         get2mass_3star_full (&stars[Nstars], &buffer[offset], Nbyte - offset);
     147        dvo_average_init (&newcat->average[Nave]);
     148        for (k = 0; k < 4; k++) {
     149          dvo_measure_init (&newcat->measure[Nmeas+k]);
     150        }
     151
     152        newcat->average[Nave].R = tstars[j].R;
     153        newcat->average[Nave].D = tstars[j].D;
     154        get2mass_3star_full (&newcat->measure[Nmeas], &buffer[offset], Nbyte - offset);
    157155
    158156        tstars[j].flag = TRUE;
    159157
    160         Nstars += 3;
    161         if (Nstars >= NSTARS - 3) {
    162           NSTARS += 3000;
    163           REALLOCATE (stars, Stars *, NSTARS);
    164         }
    165       }
    166 
    167       if (!Nstars) {
    168         free (stars);
     158        newcat->average[Nave].Nmeasure = 3;
     159        newcat->average[Nave].measureOffset = Nmeas;
     160
     161        Nave ++;
     162        Nmeas += 3;
     163
     164        CHECK_REALLOCATE (newcat->average, Average, NAVE,  Nave,  1000);
     165        CHECK_REALLOCATE (newcat->measure, Measure, NMEAS, Nmeas, 3000);
     166      }
     167      newcat->Naverage = Nave;
     168      newcat->Nmeasure = Nmeas;
     169
     170      if (!newcat->Naverage) {
     171        dvo_catalog_free (newcat);
     172        free (newcat);
    169173        continue;
    170174      }
    171175
    172       if (DEBUG) fprintf (stderr, "selected %d stars (%10.6f - %10.6f, %10.6f - %10.6f)\n", Nstars,
     176      if (DEBUG) fprintf (stderr, "selected %d stars (%10.6f - %10.6f, %10.6f - %10.6f)\n",
     177                          (int) newcat->Naverage,
    173178                          region[0].Rmin, region[0].Rmax, region[0].Dmin, region[0].Dmax);
    174179
    … …  
    193198        // assume no input star matches an existing star
    194199        // simply add to the existing table
    195         // load2mass_catalog (&catalog, stars, Nstars);
    196         find_matches_refstars (skylist[0].regions[0], stars, Nstars, &catalog, options);
    197         // load2mass_catalog (&catalog, stars, Nstars);
    198 
    199         dvo_catalog_save (&catalog, VERBOSE);
    200         dvo_catalog_unlock (&catalog);
     200        find_matches_refstars (skylist[0].regions[0], newcat, &catalog, options);
     201
     202        SetProtect (TRUE);
     203        if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     204        if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     205        SetProtect (FALSE);
    201206        dvo_catalog_free (&catalog);
    202         // free (catalog.filename);
    203         // XXX don't free this! it points to an element of the skytable
    204207      }
    205208
    206209      SkyListFree (skylist);
    207       for (j = 0; j < Nstars; j++) free (stars[j]);
    208       free (stars);
     210      dvo_catalog_free (newcat);
     211      free (newcat);
    209212      VERBOSE = verbose;
    210213    }

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

    r37807 r38986  
    1616  AddstarClientOptions options;
    1717
     18  SetSignals ();
    1819  options = ConfigInit (&argc, argv);
    1920  options = args_loadICRF (&argc, argv, options); // XXX fix args after rest is done

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

    r38471 r38986  
    2222  find_matches_ICRF (region, stars, Nstars, &catalog, options);
    2323   
    24   dvo_catalog_save (&catalog, VERBOSE);
    25   dvo_catalog_unlock (&catalog);
     24  SetProtect (TRUE);
     25  if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     26  if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     27  SetProtect (FALSE);
     28
    2629  dvo_catalog_free (&catalog);
    2730

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

    r37807 r38986  
    77
    88  // need to construct these options with args_loadICRF...
     9  SetSignals ();
    910  options = ConfigInit (&argc, argv);
    1011  options = args_loadICRF_client (&argc, argv, options);

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

    r38600 r38986  
    1313
    1414  // need to construct these options with args_loadgalphot...
     15  SetSignals ();
    1516  options = ConfigInit (&argc, argv);
    1617  options = args_loadgalphot (&argc, argv, options);

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

    r38553 r38986  
    2222  find_matches_galphot (region, stars, Nstars, &catalog, options);
    2323   
    24   dvo_catalog_save (&catalog, VERBOSE);
    25   dvo_catalog_unlock (&catalog);
     24  SetProtect (TRUE);
     25  if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     26  if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     27  SetProtect (FALSE);
     28
    2629  dvo_catalog_free (&catalog);
    2730

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

    r37807 r38986  
    1717
    1818  // need to construct these options with args_loadstarpar...
     19  SetSignals ();
    1920  options = ConfigInit (&argc, argv);
    20   options = args_loadstarpar (argc, argv, options);
     21  options = args_loadstarpar (&argc, argv, options);
    2122
    2223  // load the full sky description table (dvodb must exist)
    … …  
    2425  SkyTableSetFilenames (sky, CATDIR, "cpt");
    2526 
     27  // make the tmpdir if needed
     28  if (!loadstarpar_tmpdir()) exit (1);
     29
    2630  // load the list of hosts
    2731  HostTable *hosts = NULL;

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

    r38471 r38986  
    2222  find_matches_starpar (region, stars, Nstars, &catalog, options);
    2323   
    24   dvo_catalog_save (&catalog, VERBOSE);
    25   dvo_catalog_unlock (&catalog);
     24  SetProtect (TRUE);
     25  if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     26  if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     27  SetProtect (FALSE);
     28 
    2629  dvo_catalog_free (&catalog);
    2730

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

    r37807 r38986  
    77
    88  // need to construct these options with args_loadstarpar...
     9  SetSignals ();
    910  options = ConfigInit (&argc, argv);
    10   options = args_loadstarpar_client (argc, argv, options);
     11  options = args_loadstarpar_client (&argc, argv, options);
    1112
    1213  // client is called with a pointer to the file to be loaded
    … …  
    2021  StarPar_Stars *stars = loadstarpar_load_stars (INPUT, &Nstars);
    2122
    22   loadstarpar_catalog (stars, Nstars, skylist->regions[0], CPT_FILE, &options);
     23  char filename[DVO_MAX_PATH];
     24  snprintf (filename, DVO_MAX_PATH, "%s/%s.cpt", HOSTDIR, CPT_FILE);
     25
     26  loadstarpar_catalog (stars, Nstars, skylist->regions[0], filename, &options);
    2327
    2428  free (stars);

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

    r37807 r38986  
    2929  gfits_define_bintable_column (&theader, "D", "DEC",      "", "degree", 1.0, 0.0);
    3030  gfits_define_bintable_column (&theader, "E", "GLON",     "", "degree", 1.0, 0.0);
    31   gfits_define_bintable_column (&theader, "D", "GLAT",     "", "degree", 1.0, 0.0);
     31  gfits_define_bintable_column (&theader, "E", "GLAT",     "", "degree", 1.0, 0.0);
    3232  gfits_define_bintable_column (&theader, "E", "Ebv",      "", "", 1.0, 0.0);
    3333  gfits_define_bintable_column (&theader, "E", "dEbv",     "", "", 1.0, 0.0);
    … …  
    8484  gfits_free_table (&ftable);
    8585
     86  fflush (f);
     87  fclose (f);
     88
    8689  return TRUE;
    8790}
    8891
    8992
    90 # define GET_COLUMN(OUT,NAME,TYPE)                                      \
     93# define GET_COLUMN(OUT,NAME,TYPE,RTYPE)                                        \
    9194  TYPE *OUT = gfits_get_bintable_column_data (&theader, &ftable, NAME, type, &Nrow, &Ncol); \
    92   myAssert (!strcmp(type, #TYPE), "wrong column type");
     95  myAssert (!strcmp(type, #RTYPE), "wrong column type");
    9396
    9497StarPar_Stars *loadstarpar_load_stars (char *filename, int *nstars) {
    … …  
    134137  if (!gfits_fread_ftable_data (f, &ftable, FALSE)) goto escape;
    135138 
    136   GET_COLUMN(ra      , "RA"        ,   double);
    137   GET_COLUMN(dec     , "DEC"       ,   double);
    138   GET_COLUMN(glon    , "GLON"      ,   float);
    139   GET_COLUMN(glat    , "GLAT"      ,   float);
    140   GET_COLUMN(Ebv     , "Ebv"       ,   float);
    141   GET_COLUMN(dEbv    , "dEbv"      ,   float);
    142   GET_COLUMN(DistMag , "DistMag"   ,   float);
    143   GET_COLUMN(dDistMag, "dDistMag"  ,   float);
    144   GET_COLUMN(M_r     , "M_r"       ,   float);
    145   GET_COLUMN(dM_r    , "dM_r"      ,   float);
    146   GET_COLUMN(FeH     , "FeH"       ,   float);
    147   GET_COLUMN(dFeH    , "dFeH"      ,   float);
    148   GET_COLUMN(averef  , "averef"    ,   unsigned int);
    149   GET_COLUMN(objID   , "objID"     ,   unsigned int);
    150   GET_COLUMN(catID   , "catID"     ,   unsigned int);
     139  GET_COLUMN(ra      , "RA"        ,   double      ,   double      );
     140  GET_COLUMN(dec     , "DEC"       ,   double      ,   double      );
     141  GET_COLUMN(glon    , "GLON"      ,   float       ,   float       );
     142  GET_COLUMN(glat    , "GLAT"      ,   float       ,   float       );
     143  GET_COLUMN(Ebv     , "Ebv"       ,   float       ,   float       );
     144  GET_COLUMN(dEbv    , "dEbv"      ,   float       ,   float       );
     145  GET_COLUMN(DistMag , "DistMag"   ,   float       ,   float       );
     146  GET_COLUMN(dDistMag, "dDistMag"  ,   float       ,   float       );
     147  GET_COLUMN(M_r     , "M_r"       ,   float       ,   float       );
     148  GET_COLUMN(dM_r    , "dM_r"      ,   float       ,   float       );
     149  GET_COLUMN(FeH     , "FeH"       ,   float       ,   float       );
     150  GET_COLUMN(dFeH    , "dFeH"      ,   float       ,   float       );
     151  GET_COLUMN(averef  , "averef"    ,   unsigned int,   int         );
     152  GET_COLUMN(objID   , "objID"     ,   unsigned int,   int         );
     153  GET_COLUMN(catID   , "catID"     ,   unsigned int,   int         );
    151154
    152155  gfits_free_header (&theader);

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

    r37807 r38986  
    4747  char type[16];
    4848
    49   GET_COLUMN (glat,    "l",    float);
    50   GET_COLUMN (glon,    "b",    float);
     49  GET_COLUMN (glon,    "l",    float);
     50  GET_COLUMN (glat,    "b",    float);
    5151  GET_COLUMN (conv,    "conv", byte);
    5252  GET_COLUMN (lnZ,     "lnZ",  float);

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

    r38441 r38986  
    1818
    1919    // save to a unique filename
    20     char filename[1024]; // CATDIR/tmpdir/starpar.PID.index.fits
    21     snprintf (filename, 1024, "%s/tmpdir/starpar.%s.%05d.fits", CATDIR, uniquer, region->index);
     20    char filename[DVO_MAX_PATH]; // CATDIR/tmpdir/starpar.PID.index.fits
     21    snprintf (filename, DVO_MAX_PATH, "%s/tmpdir/starpar.%s.%05d.fits", CATDIR, uniquer, region->index);
    2222
    2323    // write the data to the given FITS file
    … …  
    5757    strextend (&command, "-input %s", filename);
    5858
     59    if (options->only_match) strextend (&command, "-only-match");
     60    if (options->replace) strextend (&command, "-replace");
     61
     62    fprintf (stderr, "command: %s\n", command);
     63
    5964    // launch the job on the remote machine (no handshake)
    6065    int errorInfo = 0;

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

    r38441 r38986  
    1515  int i, status;
    1616  SkyTable *sky;
    17   SkyList *skylist = NULL;
    1817  AddstarClientOptions options;
    1918  FITS_DB db;
    2019
    2120  // need to construct these options with args_loadWISE...
     21  SetSignals ();
    2222  options = ConfigInit (&argc, argv);
    2323  options = args_loadsupercos (&argc, argv, options);
    … …  
    2727  SkyTableSetFilenames (sky, CATDIR, "cpt");
    2828 
    29   // generate the subset matching the user-selected region
    30   skylist = SkyListByPatch (sky, -1, &UserPatch);
    31 
    32   // if we only match to existing (already populated) regions, limit the select to those regions:
    33   if (options.existing_regions) {
    34     SkyList *tmp;
    35     tmp = SkyListExistingSubset (skylist, CATDIR);
    36     SkyListFree (skylist);
    37     skylist = tmp;
    38   }
    39 
    4029  // load the images table (needed regardless)
    4130  int Nsurvey = 0;
    … …  
    6857  for (i = 3; i < argc; i++) {
    6958      fprintf (stderr, "loading %s\n", argv[i]);
    70       loadsupercos_rawdata (image, imlist, Nimage, skylist, argv[i], options);
     59      loadsupercos_rawdata (image, imlist, Nimage, sky, argv[i], options);
    7160  }
    7261  exit (0);

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

    r37036 r38986  
    7979}
    8080
    81 int loadsupercos_sortStars (Stars *tstars, int Ntstars) {
    82 
    83 # define SWAPFUNC(A,B){ Stars temp = tstars[A]; tstars[A] = tstars[B]; tstars[B] = temp; }
    84 # define COMPARE(A,B)(tstars[A].average.R < tstars[B].average.R)
    85 
    86   OHANA_SORT (Ntstars, COMPARE, SWAPFUNC);
    87 
    88 # undef SWAPFUNC
    89 # undef COMPARE
    90  
    91   return TRUE;
    92 }
    93 
    9481int *loadsupercos_image_index (Image *image, int Nimage) {
    9582

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

    r38471 r38986  
    66# define DEBUG 0
    77
    8 int loadsupercos_rawdata (Image *image, int *imlist, int Nimage, SkyList *skytable, char *filename, AddstarClientOptions options) {
     8int loadsupercos_rawdata (Image *image, int *imlist, int Nimage, SkyTable *skytable, char *filename, AddstarClientOptions options) {
    99 
    10   int i, j, verbose;
    11   int Nstars, NSTARS, Nrecords;
     10  int i;
     11  int Nrecords;
    1212 
    1313  FILE *f;
    … …  
    1515
    1616  Detection *sstars;
    17   Stars **stars, *tstars;
    18   SkyList *skylist;
    19   SkyRegion *region;
    2017  Catalog catalog;
    2118
    … …  
    2623  if (f == NULL) Shutdown ("can't read the Supercosmos data file: %s", filename);
    2724
    28   ALLOCATE (tstars, Stars, NRECORDS);
    2925  ALLOCATE (sstars, Detection, NRECORDS);
    3026
    … …  
    3329  double Dmin = +90.0;
    3430  double Dmax = -90.0;
     31
     32  Catalog *newcat = NULL;
     33  ALLOCATE (newcat, Catalog, 1);
     34  dvo_catalog_init (newcat, TRUE);
     35  ALLOCATE (newcat->average, Average, NRECORDS);
     36  ALLOCATE (newcat->measure, Measure, NRECORDS);
    3537
    3638  while ((Nrecords = fread (buffer, NBYTE, NRECORDS, f)) != 0) {
    … …  
    6264    // convert to the Stars format
    6365    for (i = 0; i < Nrecords; i++) {
    64         InitStar (&tstars[i]);
    65         tstars[i].measure.Xccd = sstars[i].xCen;
    66         tstars[i].measure.Yccd = sstars[i].yCen;
    6766
    68         tstars[i].measure.M = sstars[i].sMag;
    69         tstars[i].measure.Map = sstars[i].gMag;
    70         tstars[i].measure.photFlags = sstars[i].class;
     67        dvo_average_init (&newcat->average[i]);
     68        dvo_measure_init (&newcat->measure[i]);
    7169
    72         tstars[i].average.R = sstars[i].ra;
    73         tstars[i].average.D = sstars[i].dec;
     70        newcat->measure[i].Xccd = sstars[i].xCen;
     71        newcat->measure[i].Yccd = sstars[i].yCen;
    7472
    75         tstars[i].measure.R = sstars[i].ra;
    76         tstars[i].measure.D = sstars[i].dec;
     73        newcat->measure[i].M = sstars[i].sMag;
     74        newcat->measure[i].Map = sstars[i].gMag;
     75        newcat->measure[i].photFlags = sstars[i].class;
     76
     77        newcat->average[i].R = sstars[i].ra;
     78        newcat->average[i].D = sstars[i].dec;
     79
     80        newcat->measure[i].R = sstars[i].ra;
     81        newcat->measure[i].D = sstars[i].dec;
    7782
    7883        int Ni = imlist[sstars[i].plateID];
    … …  
    8085
    8186        // XXX fix these
    82         tstars[i].measure.Mcal = 0.0;
    83         tstars[i].measure.dt = image[Ni].exptime;
     87        newcat->measure[i].Mcal = 0.0;
     88        newcat->measure[i].dt = image[Ni].exptime;
    8489
    8590        double sidtime = image[Ni].sidtime;
    … …  
    8792       
    8893        double alt, az;
    89         altaz (&alt, &az, 15.0*sidtime - tstars[i].average.R, tstars[i].average.D, latitude);
     94        altaz (&alt, &az, 15.0*sidtime - newcat->average[i].R, newcat->average[i].D, latitude);
    9095
    91         tstars[i].measure.airmass = 1.0 / cos(RAD_DEG*alt);
    92         tstars[i].measure.az = az;
    93         tstars[i].measure.t = image[Ni].tzero;
    94         tstars[i].measure.imageID = image[Ni].imageID;
    95         tstars[i].measure.photcode = image[Ni].photcode;
     96        newcat->measure[i].airmass = 1.0 / cos(RAD_DEG*alt);
     97        newcat->measure[i].az = az;
     98        newcat->measure[i].t = image[Ni].tzero;
     99        newcat->measure[i].imageID = image[Ni].imageID;
     100        newcat->measure[i].photcode = image[Ni].photcode;
    96101
    97         tstars[i].measure.FWx = ToShortPixels(sstars[i].aU);
    98         tstars[i].measure.FWy = ToShortPixels(sstars[i].bU);
    99         tstars[i].measure.theta = ToShortDegrees(sstars[i].thetaU);
     102        newcat->measure[i].FWx = ToShortPixels(sstars[i].aU);
     103        newcat->measure[i].FWy = ToShortPixels(sstars[i].bU);
     104        newcat->measure[i].theta = ToShortDegrees(sstars[i].thetaU);
    100105
    101         Rmin = MIN (Rmin, tstars[i].average.R);
    102         Rmax = MAX (Rmax, tstars[i].average.R);
    103         Dmin = MIN (Dmin, tstars[i].average.D);
    104         Dmax = MAX (Dmax, tstars[i].average.D);
     106        Rmin = MIN (Rmin, newcat->average[i].R);
     107        Rmax = MAX (Rmax, newcat->average[i].R);
     108        Dmin = MIN (Dmin, newcat->average[i].D);
     109        Dmax = MAX (Dmax, newcat->average[i].D);
    105110    }
    106111
    107112    if (VERBOSE) fprintf (stderr, "scan %d stars (%10.6f - %10.6f, %10.6f - %10.6f) .. ", Nrecords, Rmin, Rmax, Dmin, Dmax);
    108113
    109     // sort the tstars by RA
    110     loadsupercos_sortStars (tstars, Nrecords);
     114    SkyList *skylist = SkyListForStars (skytable, -1, newcat);
    111115
    112     // scan through the stars, loading the containing catalogs
    113     // skip through table for unsaved stars
    114     for (i = 0; i < Nrecords; i++) {
    115       if (tstars[i].found != -1) continue;
     116    for (i = 0; i < skylist[0].Nregions; i++) {
     117      // now we have all of the loaded stars in this catalog
     118      dvo_catalog_init (&catalog, TRUE);
     119      catalog.filename = skylist[0].filename[0];
     120      catalog.catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data
     121      catalog.catmode   = dvo_catalog_catmode (CATMODE);      // set the default catmode from config data
     122      catalog.catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT;
     123      catalog.Nsecfilt  = GetPhotcodeNsecfilt ();
    116124
    117       // scan forward until we reach the UserPatch (stars sorted by RA)
    118       if (tstars[i].average.R < UserPatch.Rmin) continue;
    119       if (tstars[i].average.R > UserPatch.Rmax) break;
    120       if (tstars[i].average.D < UserPatch.Dmin) continue;
    121       if (tstars[i].average.D > UserPatch.Dmax) continue;
    122 
    123       // identify the relevant catalog
    124       skylist = SkyRegionByPoint_List (skytable, -1, tstars[i].average.R, tstars[i].average.D);
    125       if (skylist[0].Nregions == 0) {
    126           SkyListFree (skylist);
    127           continue;
    128       }
    129       region = skylist[0].regions[0];
    130       if (DEBUG) fprintf (stderr, "writing to %s\n", skylist[0].filename[0]);
    131 
    132       int this_image_id = tstars[i].measure.imageID;
    133 
    134       // loop over stars in this WISE region that are also in this output region
    135       Nstars = 0;
    136       NSTARS = 1000;
    137       ALLOCATE (stars, Stars *, NSTARS);
    138 
    139       for (j = i; j < Nrecords; j++) {
    140         if (tstars[j].found != -1) continue;
    141 
    142         if (tstars[j].measure.imageID != this_image_id) continue;
    143 
    144         // check if in skyregion
    145         if (tstars[j].average.R < region[0].Rmin) continue;
    146         if (tstars[j].average.R > region[0].Rmax) break;
    147         if (tstars[j].average.D < region[0].Dmin) continue;
    148         if (tstars[j].average.D > region[0].Dmax) continue;
    149          
    150         // check if in UserPatch
    151         if (tstars[j].average.R < UserPatch.Rmin) continue;
    152         if (tstars[j].average.R > UserPatch.Rmax) break;
    153         if (tstars[j].average.D < UserPatch.Dmin) continue;
    154         if (tstars[j].average.D > UserPatch.Dmax) continue;
    155 
    156         stars[Nstars] = &tstars[j];
    157         Nstars ++;
    158 
    159         CHECK_REALLOCATE (stars, Stars *, NSTARS, Nstars, 1000);
    160       }
    161          
    162       if (DEBUG) fprintf (stderr, "selected %d stars (%10.6f - %10.6f, %10.6f - %10.6f)\n", Nstars,
    163                           region[0].Rmin, region[0].Rmax, region[0].Dmin, region[0].Dmax);
    164 
    165       if (1) {
    166         verbose = VERBOSE;
    167         VERBOSE = FALSE;
    168 
    169         // now we have all of the loaded stars in this catalog
    170         dvo_catalog_init (&catalog, TRUE);
    171         catalog.filename = skylist[0].filename[0];
    172         catalog.catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data
    173         catalog.catmode   = dvo_catalog_catmode (CATMODE);      // set the default catmode from config data
    174         catalog.catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT;
    175         catalog.Nsecfilt  = GetPhotcodeNsecfilt ();
    176 
    177         // an error exit status here is a significant error
    178         if (!dvo_catalog_open (&catalog, skylist[0].regions[0], VERBOSE, "w")) {
    179           fprintf (stderr, "ERROR: failure to open/create catalog file %s\n", catalog.filename);
    180           exit (2);
    181         }
    182 
    183         // assume no input star matches an existing star
    184         // simply add to the existing table
    185         // loadWISE_catalog (&catalog, stars, Nstars);
    186         find_matches_refstars (skylist[0].regions[0], stars, Nstars, &catalog, options);
    187         // loadWISE_catalog (&catalog, stars, Nstars);
    188 
    189         dvo_catalog_save (&catalog, VERBOSE);
    190         dvo_catalog_unlock (&catalog);
    191         dvo_catalog_free (&catalog);
    192         // free (catalog.filename);
    193         // XXX don't free this! it points to an element of the skytable
     125      // an error exit status here is a significant error
     126      if (!dvo_catalog_open (&catalog, skylist[0].regions[0], VERBOSE, "w")) {
     127        fprintf (stderr, "ERROR: failure to open/create catalog file %s\n", catalog.filename);
     128        exit (2);
    194129      }
    195130
    196       SkyListFree (skylist);
     131      // assume no input star matches an existing star
     132      // simply add to the existing table
     133      find_matches_refstars (skylist[0].regions[0], newcat, &catalog, options);
    197134
    198       free (stars);
    199       VERBOSE = verbose;
     135      SetProtect (TRUE);
     136      if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     137      if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     138      SetProtect (FALSE);
     139
     140      dvo_catalog_free (&catalog);
    200141    }
     142
     143    SkyListFree (skylist);
     144    dvo_catalog_free (newcat);
     145    free (newcat);
     146   
    201147    if (VERBOSE) fprintf (stderr, "done\n");
    202148  }
    … …  
    204150  if (VERBOSE) fprintf (stderr, "\n");
    205151 
    206   free (tstars);
    207152  free (sstars);
    208153
    … …  
    225170*/
    226171
     172
     173
     174
     175
     176
     177
     178
     179
     180
     181
     182
     183
     184

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

    r38467 r38986  
    2020
    2121  // need to construct these options with args_loadtycho...
     22  SetSignals ();
    2223  options = ConfigInit (&argc, argv);
    2324  options = args_loadtycho (&argc, argv, options);

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

    r38471 r38986  
    2222
    2323  Tycho_Stars *tstars;
    24   Stars *stars, **starrefs; // this is an array of pointers to be consistent with input to find_match_refstars
    2524  SkyList *skylist;
    2625  SkyRegion *region;
    … …  
    8786      if (DEBUG) fprintf (stderr, "writing to %s\n", skylist[0].filename[0]);
    8887
    89       // collect array of (Stars *) stars in a new output catalog
    90       int Nstars = 0;
    91       int NSTARS = (NGROUP*1000);
    92       ALLOCATE (stars, Stars, NSTARS);
     88      int Nave = 0;
     89      int Nmeas = 0;
     90      int NAVE = 1000;
     91      int NMEAS = 4000;
     92
     93      Catalog *newcat = NULL;
     94      ALLOCATE (newcat, Catalog, 1);
     95      dvo_catalog_init (newcat, TRUE);
     96      ALLOCATE (newcat->average, Average, NAVE);
     97      ALLOCATE (newcat->measure, Measure, NMEAS);
    9398
    9499      // loop over stars in this WISE region that are also in this output region
    … …  
    108113        if (tstars[j].average.D > UserPatch.Dmax) continue;
    109114         
    110         for (k = 0; k < NGROUP; k++) {
    111           stars[Nstars+k].average = tstars[j].average;
    112           stars[Nstars+k].measure = tstars[j].measure[k];
    113           stars[Nstars+k].found = -1;
    114         }         
     115        dvo_average_init (&newcat->average[Nave]);
     116        newcat->average[Nave] = tstars[j].average;
     117        for (k = 0; k < NGROUP; k++) {
     118          dvo_measure_init (&newcat->measure[Nmeas + k]);
     119          newcat->measure[Nmeas + k] = tstars[j].measure[k];
     120        }
    115121        tstars[j].flag = TRUE;
    116122
    117         Nstars += NGROUP;
    118         if (Nstars >= NSTARS - NGROUP) {
    119           NSTARS += (NGROUP*1000);
    120           REALLOCATE (stars, Stars, NSTARS);
    121         }
     123        newcat->average[Nave].Nmeasure = NGROUP;
     124        newcat->average[Nave].measureOffset = Nmeas;
     125
     126        Nave ++;
     127        Nmeas += NGROUP;
     128
     129        CHECK_REALLOCATE (newcat->average, Average, NAVE,  Nave,  1000);
     130        CHECK_REALLOCATE (newcat->measure, Measure, NMEAS, Nmeas + NGROUP, 4000);
    122131      }
     132      newcat->Naverage = Nave;
     133      newcat->Nmeasure = Nmeas;
    123134
    124       ALLOCATE (starrefs, Stars *, NSTARS);
    125       for (j = 0; j < Nstars; j++) {
    126         starrefs[j] = &stars[j];
     135      if (!newcat->Naverage) {
     136        dvo_catalog_free (newcat);
     137        free (newcat);
     138        continue;
    127139      }
    128140
    … …  
    145157      // assume no input star matches an existing star
    146158      // simply add to the existing table
    147       find_matches_closest_refstars(region, starrefs, Nstars, &catalog, options);
     159      find_matches_closest_refstars(region, newcat, &catalog, options);
    148160
    149       dvo_catalog_save (&catalog, verbose);
    150       dvo_catalog_unlock (&catalog);
     161      SetProtect (TRUE);
     162      if (!dvo_catalog_save (&catalog, verbose)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     163      if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     164      SetProtect (FALSE);
     165
    151166      dvo_catalog_free (&catalog);
    152167
    153168      SkyListFree (skylist);
    154       free (stars);
    155       free (starrefs);
     169      dvo_catalog_free (newcat);
     170      free (newcat);
    156171    }
    157172    free (tstars);

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

    r37807 r38986  
    2020
    2121  // need to construct these options with args_loadWISE...
     22  SetSignals ();
    2223  options = ConfigInit (&argc, argv);
    2324  options = args_loadwise (argc, argv, options);

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

    r38471 r38986  
    202202        // loadWISE_catalog (&catalog, stars, Nstars);
    203203
    204         dvo_catalog_save (&catalog, VERBOSE);
    205         dvo_catalog_unlock (&catalog);
     204        SetProtect (TRUE);
     205        if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     206        if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     207        SetProtect (FALSE);
     208
    206209        dvo_catalog_free (&catalog);
    207210        // free (catalog.filename);

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

    r38471 r38986  
    1313 
    1414  int i, j, k, verbose;
    15   int Nstars, NSTARS, Ntstars, NTSTARS;
     15  int Ntstars, NTSTARS;
    1616  int Nbyte, Nextra, offset;
    1717
    … …  
    2121  char *buffer, *p, *q;
    2222
    23   Stars **stars; // this is an array of pointers to be consistent with input to find_match_refstars
    2423  WISE_Stars *tstars;
    2524  SkyList *skylist;
    … …  
    117116      if (DEBUG) fprintf (stderr, "writing to %s\n", skylist[0].filename[0]);
    118117
    119       // collect array of (Stars *) stars in a new output catalog
    120       Nstars = 0;
    121       NSTARS = 3000;
    122       ALLOCATE (stars, Stars *, NSTARS);
     118      int Nave = 0;
     119      int Nmeas = 0;
     120      int NAVE = 1000;
     121      int NMEAS = 4000;
     122
     123      Catalog *newcat = NULL;
     124      ALLOCATE (newcat, Catalog, 1);
     125      dvo_catalog_init (newcat, TRUE);
     126      ALLOCATE (newcat->average, Average, NAVE);
     127      ALLOCATE (newcat->measure, Measure, NMEAS);
    123128
    124129      // loop over stars in this WISE region that are also in this output region
    … …  
    140145        offset = tstars[j].offset;
    141146
     147        dvo_average_init (&newcat->average[Nave]);
    142148        for (k = 0; k < 4; k++) {
    143           ALLOCATE (stars[Nstars + k], Stars, 1);
    144           InitStar (stars[Nstars + k]);
    145           stars[Nstars+k][0].average.R = tstars[j].R;
    146           stars[Nstars+k][0].average.D = tstars[j].D;
    147           stars[Nstars+k][0].measure.R = tstars[j].R;
    148           stars[Nstars+k][0].measure.D = tstars[j].D;
    149         }         
     149          dvo_measure_init (&newcat->measure[Nmeas+k]);
     150        }
    150151       
     152        newcat->average[Nave].R = tstars[j].R;
     153        newcat->average[Nave].D = tstars[j].D;
     154
    151155        switch (MODE) {
    152156          case MODE_PRELIM:
    153             loadwise_star_prelim (&stars[Nstars], &buffer[offset], Nbyte - offset);
     157            loadwise_star_prelim (&newcat->measure[Nmeas], &buffer[offset], Nbyte - offset);
    154158            break;
    155159          case MODE_ALLSKY:
    156             loadwise_star_allsky (&stars[Nstars], &buffer[offset], Nbyte - offset);
     160            loadwise_star_allsky (&newcat->measure[Nmeas], &buffer[offset], Nbyte - offset);
    157161            break;
    158162          case MODE_ALLWISE:
    159             loadwise_star_allwise (&stars[Nstars], &buffer[offset], Nbyte - offset);
     163            loadwise_star_allwise (&newcat->measure[Nmeas], &buffer[offset], Nbyte - offset);
    160164            break;
    161165          default:
    … …  
    165169        tstars[j].flag = TRUE;
    166170
    167         Nstars += 4;
    168         if (Nstars >= NSTARS - 4) {
    169           NSTARS += 4000;
    170           REALLOCATE (stars, Stars *, NSTARS);
    171         }
    172       }
    173 
    174       if (!Nstars) {
    175         free (stars);
     171        newcat->average[Nave].Nmeasure = 4;
     172        newcat->average[Nave].measureOffset = Nmeas;
     173
     174        Nave ++;
     175        Nmeas += 4;
     176
     177        CHECK_REALLOCATE (newcat->average, Average, NAVE,  Nave,  1000);
     178        CHECK_REALLOCATE (newcat->measure, Measure, NMEAS, Nmeas, 4000);
     179      }
     180      newcat->Naverage = Nave;
     181      newcat->Nmeasure = Nmeas;
     182
     183      if (!newcat->Naverage) {
     184        dvo_catalog_free (newcat);
     185        free (newcat);
    176186        continue;
    177187      }
    178188
    179       if (DEBUG) fprintf (stderr, "selected %d stars (%10.6f - %10.6f, %10.6f - %10.6f)\n", Nstars,
     189      if (DEBUG) fprintf (stderr, "selected %d stars (%10.6f - %10.6f, %10.6f - %10.6f)\n",
     190                          (int) newcat->Naverage,
    180191                          region[0].Rmin, region[0].Rmax, region[0].Dmin, region[0].Dmax);
    181192
    … …  
    200211        // assume no input star matches an existing star
    201212        // simply add to the existing table
    202         // loadWISE_catalog (&catalog, stars, Nstars);
    203         find_matches_refstars (skylist[0].regions[0], stars, Nstars, &catalog, options);
    204         // loadWISE_catalog (&catalog, stars, Nstars);
    205 
    206         dvo_catalog_save (&catalog, VERBOSE);
    207         dvo_catalog_unlock (&catalog);
     213        find_matches_refstars (skylist[0].regions[0], newcat, &catalog, options);
     214
     215        SetProtect (TRUE);
     216        if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     217        if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     218        SetProtect (FALSE);
    208219        dvo_catalog_free (&catalog);
    209         // free (catalog.filename);
    210         // XXX don't free this! it points to an element of the skytable
    211220      }
    212221
    213222      SkyListFree (skylist);
    214       for (j = 0; j < Nstars; j++) free (stars[j]);
    215       free (stars);
     223      dvo_catalog_free (newcat);
     224      free (newcat);
    216225      VERBOSE = verbose;
    217226    }

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

    r38062 r38986  
    22# include "WISE.h"
    33
    4 int setWISE_ph_qual (Stars *star, char qual);
    5 int setWISE_var_flag_allsky (Stars *star, char qual);
    6 int setWISE_ext_flag_allsky (Stars **star, char ptr);
    7 int setWISE_var_flag_prelim (Stars *star, char qual);
    8 int setWISE_ext_flag_prelim (Stars **star, char ptr);
    9 int setWISE_cc_flag (Stars *star, char qual);
    10 int setWISE_sat_flag (Stars *star, char *ptr);
    11 int setWISE_blend_flag (Stars **star, char *ptr);
     4int setWISE_ph_qual (Measure *measure, char qual);
     5int setWISE_var_flag_allsky (Measure *measure, char qual);
     6int setWISE_ext_flag_allsky (Measure *measure, char ptr);
     7int setWISE_var_flag_prelim (Measure *measure, char qual);
     8int setWISE_ext_flag_prelim (Measure *measure, char ptr);
     9int setWISE_cc_flag (Measure *measure, char qual);
     10int setWISE_sat_flag (Measure *measure, char *ptr);
     11int setWISE_blend_flag (Measure *measure, char *ptr);
    1212
    1313// fill in the data for a WISE quad star.  takes a pointer to the start of the line the
    1414// RA and DEC have already been set
    15 int loadwise_star_allwise (Stars **star, char *line, int Nmax) {
     15int loadwise_star_allwise (Measure *measure, char *line, int Nmax) {
    1616
    1717  int i;
    … …  
    2323
    2424  // I can assign dRA and dDEC to dX and dY if I can consistently set posangle and pltscale
    25   star[0][0].measure.posangle = 0.0;
    26   star[0][0].measure.pltscale = 1.0;
     25  measure[0].posangle = 0.0;
     26  measure[0].pltscale = 1.0;
    2727
    2828  ptr = skipNbounds (ptr, '|', 3, Nmax); // skip: desig, ra, dec,
    29   star[0][0].measure.dXccd = ToShortPixels((strtod (ptr, NULL) + 0.005)); // sig_ra -- add 5/1000 to avoid truncation
     29  measure[0].dXccd = ToShortPixels((strtod (ptr, NULL) + 0.005)); // sig_ra -- add 5/1000 to avoid truncation
    3030  ptr = nextWISEfield (ptr);
    31   star[0][0].measure.dYccd = ToShortPixels((strtod (ptr, NULL) + 0.005)); // sig_dec
     31  measure[0].dYccd = ToShortPixels((strtod (ptr, NULL) + 0.005)); // sig_dec
    3232  ptr = nextWISEfield (ptr);
    3333
    3434  // we only know a single set of values for all 4 bands
    3535  for (i = 1; i < 4; i++) {
    36       star[i][0].measure.dXccd    = star[0][0].measure.dXccd;
    37       star[i][0].measure.dYccd    = star[0][0].measure.dYccd;
    38       star[i][0].measure.posangle = star[0][0].measure.posangle;
    39       star[i][0].measure.pltscale = star[0][0].measure.pltscale;
     36      measure[i].dXccd    = measure[0].dXccd;
     37      measure[i].dYccd    = measure[0].dYccd;
     38      measure[i].posangle = measure[0].posangle;
     39      measure[i].pltscale = measure[0].pltscale;
    4040  }
    4141  ptr = skipNbounds (ptr, '|', 5, Nmax); // skip: sig_radec, glon, glat, elon, elat
    4242
    43   star[0][0].measure.Xccd = strtod (ptr, NULL); // wx
     43  measure[0].Xccd = strtod (ptr, NULL); // wx
    4444  ptr = nextWISEfield (ptr); // skip wx
    45   star[0][0].measure.Yccd = strtod (ptr, NULL); // wy
     45  measure[0].Yccd = strtod (ptr, NULL); // wy
    4646  ptr = nextWISEfield (ptr); // skip wy
    4747
    4848  for (i = 1; i < 4; i++) {
    49       star[i][0].measure.Xccd    = star[0][0].measure.Xccd;
    50       star[i][0].measure.Yccd    = star[0][0].measure.Yccd;
     49      measure[i].Xccd    = measure[0].Xccd;
     50      measure[i].Yccd    = measure[0].Yccd;
    5151  }
    5252  ptr = skipNbounds (ptr, '|', 4, Nmax); // skip: cntr, source_id, coadd_id, src
    … …  
    5555  for (i = 0; i < 4; i++) {
    5656    char *endpoint;
    57       star[i][0].measure.M  = strtod (ptr, &endpoint); // w?mpro
     57      measure[i].M  = strtod (ptr, &endpoint); // w?mpro
    5858      if (endpoint == ptr) {
    59         star[i][0].measure.M  = NAN;
     59        measure[i].M  = NAN;
    6060      }
    6161      ptr = nextWISEfield (ptr);
    62       star[i][0].measure.dM = strtod (ptr, &endpoint); // w?sigmpro
     62      measure[i].dM = strtod (ptr, &endpoint); // w?sigmpro
    6363      if (endpoint == ptr) {
    64         star[i][0].measure.dM  = NAN;
     64        measure[i].dM  = NAN;
    6565      }
    6666      ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w?sigmpro, w?snr
    67       star[i][0].measure.psfChisq = strtod (ptr, NULL); // w?rchi2
    68       star[i][0].measure.psfQF = strtod (ptr, NULL); // w?rchi2
     67      measure[i].psfChisq = strtod (ptr, NULL); // w?rchi2
     68      measure[i].psfQF = strtod (ptr, NULL); // w?rchi2
    6969      ptr = nextWISEfield (ptr); // skip : w1rchi2
    7070
    7171      // init the photFlags field
    72       star[i][0].measure.photFlags = 0;
     72      measure[i].photFlags = 0;
    7373  }
    7474
    … …  
    7676
    7777  // set blend flags for all 4 measures
    78   setWISE_blend_flag (star, ptr); // nb & na both used here
     78  setWISE_blend_flag (measure, ptr); // nb & na both used here
    7979  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: nb, na
    8080
    8181  for (i = 0; i < 4; i++) {
    82       setWISE_sat_flag (star[i], ptr); // w1sat
     82      setWISE_sat_flag (&measure[i], ptr); // w1sat
    8383      ptr = nextWISEfield (ptr);
    8484  }
    … …  
    8888
    8989  for (i = 0; i < 4; i++) {
    90       setWISE_cc_flag (star[i], ptr[i]); // cc_flags
     90      setWISE_cc_flag (&measure[i], ptr[i]); // cc_flags
    9191  }
    9292  ptr = nextWISEfield (ptr); // skip cc_flags
    … …  
    9494
    9595  // set ext flags for all 4 measures
    96   setWISE_ext_flag_allsky (star, ptr[0]); // ext_flg
     96  setWISE_ext_flag_allsky (measure, ptr[0]); // ext_flg
    9797  ptr = nextWISEfield (ptr); // skip ext_flags
    9898
    9999  for (i = 0; i < 4; i++) {
    100       setWISE_var_flag_allsky (star[i], ptr[i]); // var_flg
     100      setWISE_var_flag_allsky (&measure[i], ptr[i]); // var_flg
    101101  }
    102102  ptr = nextWISEfield (ptr); // skip var_flags
    103103
    104104  for (i = 0; i < 4; i++) {
    105       setWISE_ph_qual (star[i], ptr[i]); // ph_qual
     105      setWISE_ph_qual (&measure[i], ptr[i]); // ph_qual
    106106  }
    107107
    … …  
    123123    // the release is based on data taken in the period 14 January 2010 to 29 April 2010
    124124    if (mjdmean == 0.0) {
    125       star[i][0].measure.t = 0;
     125      measure[i].t = 0;
    126126    } else {
    127       star[i][0].measure.t = ohana_mjd_to_sec (mjdmean);
     127      measure[i].t = ohana_mjd_to_sec (mjdmean);
    128128    }
    129129  }
    130130
    131   star[0][0].measure.photcode  = WISE_W1;
    132   star[0][0].measure.detID   = 0;
    133   star[0][0].measure.imageID = 0;
    134 
    135   star[1][0].measure.photcode  = WISE_W2;
    136   star[1][0].measure.detID   = 0;
    137   star[1][0].measure.imageID = 0;
    138 
    139   star[2][0].measure.photcode  = WISE_W3;
    140   star[2][0].measure.detID   = 0;
    141   star[2][0].measure.imageID = 0;
    142 
    143   star[3][0].measure.photcode  = WISE_W4;
    144   star[3][0].measure.detID   = 0;
    145   star[3][0].measure.imageID = 0;
     131  measure[0].photcode  = WISE_W1;
     132  measure[0].detID   = 0;
     133  measure[0].imageID = 0;
     134
     135  measure[1].photcode  = WISE_W2;
     136  measure[1].detID   = 0;
     137  measure[1].imageID = 0;
     138
     139  measure[2].photcode  = WISE_W3;
     140  measure[2].detID   = 0;
     141  measure[2].imageID = 0;
     142
     143  measure[3].photcode  = WISE_W4;
     144  measure[3].detID   = 0;
     145  measure[3].imageID = 0;
    146146
    147147  return TRUE;
    … …  
    156156// fill in the data for a WISE quad star.  takes a pointer to the start of the line the
    157157// RA and DEC have already been set
    158 int loadwise_star_allsky (Stars **star, char *line, int Nmax) {
     158int loadwise_star_allsky (Measure *measure, char *line, int Nmax) {
    159159
    160160  int i;
    … …  
    166166
    167167  // I can assign dRA and dDEC to dX and dY if I can consistently set posangle and pltscale
    168   star[0][0].measure.posangle = 0.0;
    169   star[0][0].measure.pltscale = 1.0;
     168  measure[0].posangle = 0.0;
     169  measure[0].pltscale = 1.0;
    170170
    171171  ptr = skipNbounds (ptr, '|', 3, Nmax); // skip: desig, ra, dec,
    172   star[0][0].measure.dXccd = ToShortPixels(strtod (ptr, NULL)); // sig_ra
     172  measure[0].dXccd = ToShortPixels(strtod (ptr, NULL)); // sig_ra
    173173  ptr = nextWISEfield (ptr);
    174   star[0][0].measure.dYccd = ToShortPixels(strtod (ptr, NULL)); // sig_dec
     174  measure[0].dYccd = ToShortPixels(strtod (ptr, NULL)); // sig_dec
    175175  ptr = nextWISEfield (ptr);
    176176
    177177  // we only know a single set of values for all 4 bands
    178178  for (i = 1; i < 4; i++) {
    179       star[i][0].measure.dXccd    = star[0][0].measure.dXccd;
    180       star[i][0].measure.dYccd    = star[0][0].measure.dYccd;
    181       star[i][0].measure.posangle = star[0][0].measure.posangle;
    182       star[i][0].measure.pltscale = star[0][0].measure.pltscale;
     179      measure[i].dXccd    = measure[0].dXccd;
     180      measure[i].dYccd    = measure[0].dYccd;
     181      measure[i].posangle = measure[0].posangle;
     182      measure[i].pltscale = measure[0].pltscale;
    183183  }
    184184  ptr = skipNbounds (ptr, '|', 5, Nmax); // skip: sig_radec, glon, glat, elon, elat
    185185
    186   star[0][0].measure.Xccd = strtod (ptr, NULL); // wx
     186  measure[0].Xccd = strtod (ptr, NULL); // wx
    187187  ptr = nextWISEfield (ptr); // skip wx
    188   star[0][0].measure.Yccd = strtod (ptr, NULL); // wy
     188  measure[0].Yccd = strtod (ptr, NULL); // wy
    189189  ptr = nextWISEfield (ptr); // skip wy
    190190
    191191  for (i = 1; i < 4; i++) {
    192       star[i][0].measure.Xccd    = star[0][0].measure.Xccd;
    193       star[i][0].measure.Yccd    = star[0][0].measure.Yccd;
     192      measure[i].Xccd    = measure[0].Xccd;
     193      measure[i].Yccd    = measure[0].Yccd;
    194194  }
    195195  ptr = skipNbounds (ptr, '|', 4, Nmax); // skip: cntr, source_id, coadd_id, src
    … …  
    198198  for (i = 0; i < 4; i++) {
    199199    char *endpoint;
    200       star[i][0].measure.M  = strtod (ptr, &endpoint); // w?mpro
     200      measure[i].M  = strtod (ptr, &endpoint); // w?mpro
    201201      if (endpoint == ptr) {
    202         star[i][0].measure.M  = NAN;
     202        measure[i].M  = NAN;
    203203      }
    204204      ptr = nextWISEfield (ptr);
    205       star[i][0].measure.dM = strtod (ptr, &endpoint); // w?sigmpro
     205      measure[i].dM = strtod (ptr, &endpoint); // w?sigmpro
    206206      if (endpoint == ptr) {
    207         star[i][0].measure.dM  = NAN;
     207        measure[i].dM  = NAN;
    208208      }
    209209      ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w?sigmpro, w?snr
    210       star[i][0].measure.psfChisq = strtod (ptr, NULL); // w?rchi2
     210      measure[i].psfChisq = strtod (ptr, NULL); // w?rchi2
    211211      ptr = nextWISEfield (ptr); // skip : w1rchi2
    212212
    213213      // init the photFlags field
    214       star[i][0].measure.photFlags = 0;
     214      measure[i].photFlags = 0;
    215215  }
    216216
    … …  
    218218
    219219  // set blend flags for all 4 measures
    220   setWISE_blend_flag (star, ptr); // nb & na both used here
     220  setWISE_blend_flag (measure, ptr); // nb & na both used here
    221221  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: nb, na
    222222
    223223  for (i = 0; i < 4; i++) {
    224       setWISE_sat_flag (star[i], ptr); // w1sat
     224      setWISE_sat_flag (&measure[i], ptr); // w1sat
    225225      ptr = nextWISEfield (ptr);
    226226  }
    … …  
    228228
    229229  for (i = 0; i < 4; i++) {
    230       setWISE_cc_flag (star[i], ptr[i]); // cc_flg
     230      setWISE_cc_flag (&measure[i], ptr[i]); // cc_flg
    231231  }
    232232  ptr = nextWISEfield (ptr); // skip cc_flags
    233233
    234234  // set ext flags for all 4 measures
    235   setWISE_ext_flag_allsky (star, ptr[0]); // ext_flg
     235  setWISE_ext_flag_allsky (measure, ptr[0]); // ext_flg
    236236  ptr = nextWISEfield (ptr); // skip ext_flags
    237237
    238238  for (i = 0; i < 4; i++) {
    239       setWISE_var_flag_allsky (star[i], ptr[i]); // var_flg
     239      setWISE_var_flag_allsky (&measure[i], ptr[i]); // var_flg
    240240  }
    241241  ptr = nextWISEfield (ptr); // skip var_flags
    242242
    243243  for (i = 0; i < 4; i++) {
    244       setWISE_ph_qual (star[i], ptr[i]); // ph_qual
     244      setWISE_ph_qual (&measure[i], ptr[i]); // ph_qual
    245245  }
    246246
    … …  
    261261    // the release is based on data taken in the period 14 January 2010 to 29 April 2010
    262262    if (mjdmean == 0.0) {
    263       star[i][0].measure.t = 0;
     263      measure[i].t = 0;
    264264    } else {
    265       star[i][0].measure.t = ohana_mjd_to_sec (mjdmean);
     265      measure[i].t = ohana_mjd_to_sec (mjdmean);
    266266    }
    267267  }
    268268
    269   star[0][0].measure.photcode  = WISE_W1;
    270   star[0][0].measure.detID   = 0;
    271   star[0][0].measure.imageID = 0;
    272 
    273   star[1][0].measure.photcode  = WISE_W2;
    274   star[1][0].measure.detID   = 0;
    275   star[1][0].measure.imageID = 0;
    276 
    277   star[2][0].measure.photcode  = WISE_W3;
    278   star[2][0].measure.detID   = 0;
    279   star[2][0].measure.imageID = 0;
    280 
    281   star[3][0].measure.photcode  = WISE_W4;
    282   star[3][0].measure.detID   = 0;
    283   star[3][0].measure.imageID = 0;
     269  measure[0].photcode  = WISE_W1;
     270  measure[0].detID   = 0;
     271  measure[0].imageID = 0;
     272
     273  measure[1].photcode  = WISE_W2;
     274  measure[1].detID   = 0;
     275  measure[1].imageID = 0;
     276
     277  measure[2].photcode  = WISE_W3;
     278  measure[2].detID   = 0;
     279  measure[2].imageID = 0;
     280
     281  measure[3].photcode  = WISE_W4;
     282  measure[3].detID   = 0;
     283  measure[3].imageID = 0;
    284284
    285285  return TRUE;
    … …  
    288288// fill in the data for a WISE quad star.  takes a pointer to the start of the line the
    289289// RA and DEC have already been set
    290 int loadwise_star_prelim (Stars **star, char *line, int Nmax) {
     290int loadwise_star_prelim (Measure *measure, char *line, int Nmax) {
    291291
    292292  int i;
    … …  
    298298
    299299  // I can assign dRA and dDEC to dX and dY if I can consistently set posangle and pltscale
    300   star[0][0].measure.posangle = 0.0;
    301   star[0][0].measure.pltscale = 1.0;
     300  measure[0].posangle = 0.0;
     301  measure[0].pltscale = 1.0;
    302302
    303303  ptr = skipNbounds (ptr, '|', 3, Nmax); // skip: desig, ra, dec,
    304   star[0][0].measure.dXccd = ToShortPixels(strtod (ptr, NULL)); // sig_ra
     304  measure[0].dXccd = ToShortPixels(strtod (ptr, NULL)); // sig_ra
    305305  ptr = nextWISEfield (ptr);
    306   star[0][0].measure.dYccd = ToShortPixels(strtod (ptr, NULL)); // sig_dec
     306  measure[0].dYccd = ToShortPixels(strtod (ptr, NULL)); // sig_dec
    307307  ptr = nextWISEfield (ptr);
    308308
    309309  // we only know a single set of values for all 4 bands
    310310  for (i = 1; i < 4; i++) {
    311       star[i][0].measure.dXccd    = star[0][0].measure.dXccd;
    312       star[i][0].measure.dYccd    = star[0][0].measure.dYccd;
    313       star[i][0].measure.posangle = star[0][0].measure.posangle;
    314       star[i][0].measure.pltscale = star[0][0].measure.pltscale;
     311      measure[i].dXccd    = measure[0].dXccd;
     312      measure[i].dYccd    = measure[0].dYccd;
     313      measure[i].posangle = measure[0].posangle;
     314      measure[i].pltscale = measure[0].pltscale;
    315315  }
    316316  ptr = skipNbounds (ptr, '|', 5, Nmax); // skip: sig_radec, glon, glat, elon, elat
    317317
    318   star[0][0].measure.Xccd = strtod (ptr, NULL); // wx
     318  measure[0].Xccd = strtod (ptr, NULL); // wx
    319319  ptr = nextWISEfield (ptr); // skip wx
    320   star[0][0].measure.Yccd = strtod (ptr, NULL); // wy
     320  measure[0].Yccd = strtod (ptr, NULL); // wy
    321321  ptr = nextWISEfield (ptr); // skip wy
    322322
    323323  for (i = 1; i < 4; i++) {
    324       star[i][0].measure.Xccd    = star[0][0].measure.Xccd;
    325       star[i][0].measure.Yccd    = star[0][0].measure.Yccd;
     324      measure[i].Xccd    = measure[0].Xccd;
     325      measure[i].Yccd    = measure[0].Yccd;
    326326  }
    327327  ptr = skipNbounds (ptr, '|', 4, Nmax); // skip: cntr, source_id, coadd_id, src
    … …  
    329329  // W1
    330330  for (i = 0; i < 4; i++) {
    331       star[i][0].measure.M  = strtod (ptr, NULL); // w?mpro
     331      measure[i].M  = strtod (ptr, NULL); // w?mpro
    332332      ptr = nextWISEfield (ptr);
    333       star[i][0].measure.dM = strtod (ptr, NULL); // w?sigmpro
     333      measure[i].dM = strtod (ptr, NULL); // w?sigmpro
    334334      ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: w?sigmpro, w?snr
    335       star[i][0].measure.psfChisq = strtod (ptr, NULL); // w?rchi2
     335      measure[i].psfChisq = strtod (ptr, NULL); // w?rchi2
    336336      ptr = nextWISEfield (ptr); // skip : w1rchi2
    337337
    338338      // init the photFlags field
    339       star[i][0].measure.photFlags = 0;
     339      measure[i].photFlags = 0;
    340340  }
    341341
    … …  
    343343
    344344  // set blend flags for all 4 measures
    345   setWISE_blend_flag (star, ptr); // nb & na both used here
     345  setWISE_blend_flag (measure, ptr); // nb & na both used here
    346346  ptr = skipNbounds (ptr, '|', 2, Nmax); // skip: nb, na
    347347
    348348  for (i = 0; i < 4; i++) {
    349       setWISE_sat_flag (star[i], ptr); // w1sat
     349      setWISE_sat_flag (&measure[i], ptr); // w1sat
    350350      ptr = nextWISEfield (ptr);
    351351  }
    … …  
    353353
    354354  for (i = 0; i < 4; i++) {
    355       setWISE_cc_flag (star[i], ptr[i]); // cc_flg
     355      setWISE_cc_flag (&measure[i], ptr[i]); // cc_flg
    356356  }
    357357  ptr = nextWISEfield (ptr); // skip cc_flags
    358358
    359359  // set ext flags for all 4 measures
    360   setWISE_ext_flag_prelim (star, *ptr); // ext_flg
     360  setWISE_ext_flag_prelim (measure, *ptr); // ext_flg
    361361  ptr = nextWISEfield (ptr); // skip ext_flags
    362362
    363363  for (i = 0; i < 4; i++) {
    364       setWISE_var_flag_prelim (star[i], ptr[i]); // var_flg
     364      setWISE_var_flag_prelim (&measure[i], ptr[i]); // var_flg
    365365  }
    366366  ptr = nextWISEfield (ptr); // skip var_flags
    367367
    368368  for (i = 0; i < 4; i++) {
    369       setWISE_ph_qual (star[i], ptr[i]); // ph_qual
     369      setWISE_ph_qual (&measure[i], ptr[i]); // ph_qual
    370370  }
    371371
    372372  double jd = 2455263.0; // NOTE : WISE prelim release does not contain per-detection time info.
    373373  // the release is based on data taken in the period 14 January 2010 to 29 April 2010
    374   star[0][0].measure.t = ohana_jd_to_sec (jd);
    375   star[1][0].measure.t = star[0][0].measure.t;
    376   star[2][0].measure.t = star[0][0].measure.t;
    377   star[3][0].measure.t = star[0][0].measure.t;
    378 
    379   star[0][0].measure.photcode  = WISE_W1;
    380   star[0][0].measure.detID   = 0;
    381   star[0][0].measure.imageID = 0;
    382 
    383   star[1][0].measure.photcode  = WISE_W2;
    384   star[1][0].measure.detID   = 0;
    385   star[1][0].measure.imageID = 0;
    386 
    387   star[2][0].measure.photcode  = WISE_W3;
    388   star[2][0].measure.detID   = 0;
    389   star[2][0].measure.imageID = 0;
    390 
    391   star[3][0].measure.photcode  = WISE_W4;
    392   star[3][0].measure.detID   = 0;
    393   star[3][0].measure.imageID = 0;
     374  measure[0].t = ohana_jd_to_sec (jd);
     375  measure[1].t = measure[0].t;
     376  measure[2].t = measure[0].t;
     377  measure[3].t = measure[0].t;
     378
     379  measure[0].photcode  = WISE_W1;
     380  measure[0].detID   = 0;
     381  measure[0].imageID = 0;
     382
     383  measure[1].photcode  = WISE_W2;
     384  measure[1].detID   = 0;
     385  measure[1].imageID = 0;
     386
     387  measure[2].photcode  = WISE_W3;
     388  measure[2].detID   = 0;
     389  measure[2].imageID = 0;
     390
     391  measure[3].photcode  = WISE_W4;
     392  measure[3].detID   = 0;
     393  measure[3].imageID = 0;
    394394
    395395  return TRUE;
    … …  
    436436# define FLAG_VARIABLE_LEVEL3 0x40000000 // var_flg == 8 or 9
    437437
    438 int setWISE_blend_flag (Stars **star, char *ptr) {
     438int setWISE_blend_flag (Measure *measure, char *ptr) {
    439439
    440440    int nb = atoi (ptr);
    … …  
    445445
    446446    if (na == 0) {
    447         star[0][0].measure.photFlags |= FLAG_BLEND_ACTIVE;
    448         star[1][0].measure.photFlags |= FLAG_BLEND_ACTIVE;
    449         star[2][0].measure.photFlags |= FLAG_BLEND_ACTIVE;
    450         star[3][0].measure.photFlags |= FLAG_BLEND_ACTIVE;
     447        measure[0].photFlags |= FLAG_BLEND_ACTIVE;
     448        measure[1].photFlags |= FLAG_BLEND_ACTIVE;
     449        measure[2].photFlags |= FLAG_BLEND_ACTIVE;
     450        measure[3].photFlags |= FLAG_BLEND_ACTIVE;
    451451    } else {
    452         star[0][0].measure.photFlags |= FLAG_BLEND_PASSIVE;
    453         star[1][0].measure.photFlags |= FLAG_BLEND_PASSIVE;
    454         star[2][0].measure.photFlags |= FLAG_BLEND_PASSIVE;
    455         star[3][0].measure.photFlags |= FLAG_BLEND_PASSIVE;
     452        measure[0].photFlags |= FLAG_BLEND_PASSIVE;
     453        measure[1].photFlags |= FLAG_BLEND_PASSIVE;
     454        measure[2].photFlags |= FLAG_BLEND_PASSIVE;
     455        measure[3].photFlags |= FLAG_BLEND_PASSIVE;
    456456    }
    457457    return TRUE;
    458458}
    459459
    460 int setWISE_sat_flag (Stars *star, char *ptr) {
     460int setWISE_sat_flag (Measure *measure, char *ptr) {
    461461
    462462    float sat = strtod (ptr, NULL);
    463463    if (sat > 0.0) {
    464         star[0].measure.photFlags |= FLAG_SATURATED_PIX;
     464        measure[0].photFlags |= FLAG_SATURATED_PIX;
    465465    }
    466466    return TRUE;
    467467}
    468468
    469 int setWISE_cc_flag (Stars *star, char qual) {
     469int setWISE_cc_flag (Measure *measure, char qual) {
    470470
    471471  switch (qual) {
    472     case 'p': star[0].measure.photFlags |= FLAG_CC_PERSIST; break;
    473     case 'h': star[0].measure.photFlags |= FLAG_CC_HALO;    break;
    474     case 'd': star[0].measure.photFlags |= FLAG_CC_SPIKE;   break;
    475     case 'o': star[0].measure.photFlags |= FLAG_CC_GHOST;   break;
    476 
    477     case 'P': star[0].measure.photFlags |= FLAG_CC_PERSIST | FLAG_CC_SPURIOUS; break;
    478     case 'H': star[0].measure.photFlags |= FLAG_CC_HALO    | FLAG_CC_SPURIOUS; break;
    479     case 'D': star[0].measure.photFlags |= FLAG_CC_SPIKE   | FLAG_CC_SPURIOUS; break;
    480     case 'O': star[0].measure.photFlags |= FLAG_CC_GHOST   | FLAG_CC_SPURIOUS; break;
     472    case 'p': measure[0].photFlags |= FLAG_CC_PERSIST; break;
     473    case 'h': measure[0].photFlags |= FLAG_CC_HALO;    break;
     474    case 'd': measure[0].photFlags |= FLAG_CC_SPIKE;   break;
     475    case 'o': measure[0].photFlags |= FLAG_CC_GHOST;   break;
     476
     477    case 'P': measure[0].photFlags |= FLAG_CC_PERSIST | FLAG_CC_SPURIOUS; break;
     478    case 'H': measure[0].photFlags |= FLAG_CC_HALO    | FLAG_CC_SPURIOUS; break;
     479    case 'D': measure[0].photFlags |= FLAG_CC_SPIKE   | FLAG_CC_SPURIOUS; break;
     480    case 'O': measure[0].photFlags |= FLAG_CC_GHOST   | FLAG_CC_SPURIOUS; break;
    481481
    482482    case '0': break;
    … …  
    487487}
    488488
    489 int setWISE_ext_flag_allsky (Stars **star, char value) {
     489int setWISE_ext_flag_allsky (Measure *measure, char value) {
    490490
    491491  switch (value) {
    … …  
    493493      return TRUE;
    494494    case '1':
    495       star[0][0].measure.photFlags |= FLAG_EXTENDED;
    496       star[1][0].measure.photFlags |= FLAG_EXTENDED;
    497       star[2][0].measure.photFlags |= FLAG_EXTENDED;
    498       star[3][0].measure.photFlags |= FLAG_EXTENDED;
     495      measure[0].photFlags |= FLAG_EXTENDED;
     496      measure[1].photFlags |= FLAG_EXTENDED;
     497      measure[2].photFlags |= FLAG_EXTENDED;
     498      measure[3].photFlags |= FLAG_EXTENDED;
    499499      return TRUE;
    500500    case '2':
    501       star[0][0].measure.photFlags |= FLAG_EXT_IN_XSC;
    502       star[1][0].measure.photFlags |= FLAG_EXT_IN_XSC;
    503       star[2][0].measure.photFlags |= FLAG_EXT_IN_XSC;
    504       star[3][0].measure.photFlags |= FLAG_EXT_IN_XSC;
     501      measure[0].photFlags |= FLAG_EXT_IN_XSC;
     502      measure[1].photFlags |= FLAG_EXT_IN_XSC;
     503      measure[2].photFlags |= FLAG_EXT_IN_XSC;
     504      measure[3].photFlags |= FLAG_EXT_IN_XSC;
    505505      return TRUE;
    506506    case '3':
    507       star[0][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
    508       star[1][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
    509       star[2][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
    510       star[3][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
     507      measure[0].photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
     508      measure[1].photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
     509      measure[2].photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
     510      measure[3].photFlags |= FLAG_EXTENDED | FLAG_EXT_IN_XSC;
    511511      return TRUE;
    512512    case '4':
    513       star[0][0].measure.photFlags |= FLAG_EXT_BY_XSC;
    514       star[1][0].measure.photFlags |= FLAG_EXT_BY_XSC;
    515       star[2][0].measure.photFlags |= FLAG_EXT_BY_XSC;
    516       star[3][0].measure.photFlags |= FLAG_EXT_BY_XSC;
     513      measure[0].photFlags |= FLAG_EXT_BY_XSC;
     514      measure[1].photFlags |= FLAG_EXT_BY_XSC;
     515      measure[2].photFlags |= FLAG_EXT_BY_XSC;
     516      measure[3].photFlags |= FLAG_EXT_BY_XSC;
    517517      return TRUE;
    518518    case '5':
    519       star[0][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
    520       star[1][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
    521       star[2][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
    522       star[3][0].measure.photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
     519      measure[0].photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
     520      measure[1].photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
     521      measure[2].photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
     522      measure[3].photFlags |= FLAG_EXTENDED | FLAG_EXT_BY_XSC;
    523523      return TRUE;
    524524    default:
    … …  
    529529}
    530530
    531 int setWISE_ext_flag_prelim (Stars **star, char value) {
     531int setWISE_ext_flag_prelim (Measure *measure, char value) {
    532532
    533533  switch (value) {
    … …  
    535535      return TRUE;
    536536    case '1':
    537       star[0][0].measure.photFlags |= FLAG_EXTENDED;
    538       star[1][0].measure.photFlags |= FLAG_EXTENDED;
    539       star[2][0].measure.photFlags |= FLAG_EXTENDED;
    540       star[3][0].measure.photFlags |= FLAG_EXTENDED;
     537      measure[0].photFlags |= FLAG_EXTENDED;
     538      measure[1].photFlags |= FLAG_EXTENDED;
     539      measure[2].photFlags |= FLAG_EXTENDED;
     540      measure[3].photFlags |= FLAG_EXTENDED;
    541541      return TRUE;
    542542    default:
    … …  
    548548
    549549// NOTE: var flag definition changed slightly between prelim & allsky
    550 int setWISE_var_flag_allsky (Stars *star, char qual) {
     550int setWISE_var_flag_allsky (Measure *measure, char qual) {
    551551
    552552  switch (qual) {
    … …  
    559559    case '4':
    560560    case '5':
    561         star[0].measure.photFlags |= FLAG_VARIABLE_LEVEL1;
     561        measure[0].photFlags |= FLAG_VARIABLE_LEVEL1;
    562562        return TRUE;
    563563    case '6':
    564564    case '7':
    565         star[0].measure.photFlags |= FLAG_VARIABLE_LEVEL2;
     565        measure[0].photFlags |= FLAG_VARIABLE_LEVEL2;
    566566        return TRUE;
    567567    case '8':
    568568    case '9':
    569       star[0].measure.photFlags |= FLAG_VARIABLE_LEVEL3;
     569      measure[0].photFlags |= FLAG_VARIABLE_LEVEL3;
    570570      return TRUE;
    571571    default:
    … …  
    575575}
    576576
    577 int setWISE_var_flag_prelim (Stars *star, char qual) {
     577int setWISE_var_flag_prelim (Measure *measure, char qual) {
    578578
    579579  switch (qual) {
    … …  
    584584    case '3':
    585585    case '4':
    586         star[0].measure.photFlags |= FLAG_VARIABLE_LEVEL1;
     586        measure[0].photFlags |= FLAG_VARIABLE_LEVEL1;
    587587        return TRUE;
    588588    case '5':
    589589    case '6':
    590590    case '7':
    591         star[0].measure.photFlags |= FLAG_VARIABLE_LEVEL2;
     591        measure[0].photFlags |= FLAG_VARIABLE_LEVEL2;
    592592        return TRUE;
    593593    case '8':
    594594    case '9':
    595       star[0].measure.photFlags |= FLAG_VARIABLE_LEVEL3;
     595      measure[0].photFlags |= FLAG_VARIABLE_LEVEL3;
    596596      return TRUE;
    597597    default:
    … …  
    601601}
    602602
    603 int setWISE_ph_qual (Stars *star, char qual) {
     603int setWISE_ph_qual (Measure *measure, char qual) {
    604604
    605605  switch (qual) {
    606     case 'A': star[0].measure.photFlags |= FLAG_PH_A; break;
    607     case 'B': star[0].measure.photFlags |= FLAG_PH_B; break;
    608     case 'C': star[0].measure.photFlags |= FLAG_PH_C; break;
    609     case 'U': star[0].measure.photFlags |= FLAG_PH_U; break;
    610     case 'X': star[0].measure.photFlags |= FLAG_PH_X; break;
    611     case 'Z': star[0].measure.photFlags |= FLAG_PH_Z; break;
     606    case 'A': measure[0].photFlags |= FLAG_PH_A; break;
     607    case 'B': measure[0].photFlags |= FLAG_PH_B; break;
     608    case 'C': measure[0].photFlags |= FLAG_PH_C; break;
     609    case 'U': measure[0].photFlags |= FLAG_PH_U; break;
     610    case 'X': measure[0].photFlags |= FLAG_PH_X; break;
     611    case 'Z': measure[0].photFlags |= FLAG_PH_Z; break;
    612612    default:
    613613      fprintf (stderr, "error in ph_flag: %c\n", qual);

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

    r37036 r38986  
    11# include "addstar.h"
    22
    3 int replace_match (Average *average, Measure *measure, Stars *star) {
     3int replace_match (Average *average, Measure *measure, Measure *newmeas, off_t *found) {
    44
    55  int i, j, m;
    … …  
    1111  for (i = 0; i < average[0].Nmeasure; i++) {
    1212    j = i + m;
    13     if (measure[j].photcode != star[0].measure.photcode) continue;
    14     measure[j].R = star[0].average.R;
    15     measure[j].D = star[0].average.D;
    16     measure[j].M  = star[0].measure.M;
    17     measure[j].dM = star[0].measure.dM;
    18     star[0].found = average[0].measureOffset + i;
     13    if (measure[j].photcode != newmeas->photcode) continue;
     14    measure[j].R  = newmeas->R;
     15    measure[j].D  = newmeas->D;
     16    measure[j].M  = newmeas->M;
     17    measure[j].dM = newmeas->dM;
     18    *found = average[0].measureOffset + i;
    1919    return (TRUE);
    2020  }

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

    r38638 r38986  
    5555      // earlier formats did not carry the objID or catID, so they are not available (we could assign on load, but we don't)
    5656      myAssert(average[averageSeq[i]].catID == measure[measureSeq[i]].catID, "object / detection mismatch");
    57 # if (1)
    5857      myAssert (average[averageSeq[i]].objID == measure[measureSeq[i]].objID, "object ID mismatch?");
    59 # endif
    6058# if (0)
    6159      // myAssert(average[averageSeq[i]].objID == measure[measureSeq[i]].objID, "object / detection mismatch");
    62       // check if the objID is correct. if not, check if it is byte-swapped (this has happened) and repair if so. 
    63       // otherwise, abort
     60
     61      // Check some possible causes for objID failures
    6462      if (average[averageSeq[i]].objID != measure[measureSeq[i]].objID) {
    6563        fprintf (stderr, "object / detection mismatch average.objID = %d, measure.objID = %d, catID: %d, detID: %d",
    6664                 average[averageSeq[i]].objID, measure[measureSeq[i]].objID,
    6765                 measure[measureSeq[i]].catID, measure[measureSeq[i]].detID);
     66        // is the byte-swapped value the correct objID?
    6867        int objIDalt = measure[measureSeq[i]].objID;
    6968        char *byte = (char *) &objIDalt;
    … …  
    7271        tmp = byte[1]; byte[1] = byte[2]; byte[2] = tmp;
    7372        if (average[averageSeq[i]].objID == objIDalt) {
    74           fprintf (stderr, "objID is byte-swapped, repairing\n");
    75           measure[measureSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this...
    76         } else if (measure[measureSeq[i]].objID == 0) {
    77           fprintf (stderr, "objID is 0, repairing\n");
    78           measure[measureSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this...
     73          myAbort ("measure.objID is byte-swapped, consider repairing\n");
     74          // measure[measureSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this...
     75        }
     76        if (measure[measureSeq[i]].objID == 0) {
     77          myAbort ("measure.objID is 0, repairing\n");
     78          // measure[measureSeq[i]].objID = average[averageSeq[i]].objID; // XXX I don't really like this...
    7979        } else {
    80           myAbort ("objID is NOT byte-swapped, aborting\n");
     80          myAbort ("objID is NOT byte-swapped and NOT 0, aborting\n");
    8181        }
    8282      }

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

    r38636 r38986  
    8181    // write out catalog, if appropriate
    8282    SetProtect (TRUE);
    83     dvo_catalog_save (&catalog, VERBOSE);
     83    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     84    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
    8485    SetProtect (FALSE);
    85     dvo_catalog_unlock (&catalog);
     86
    8687    dvo_catalog_free (&catalog);
    8788    threadData->state = TS_DONE;

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

    r38636 r38986  
    5252    // write out catalog, if appropriate
    5353    SetProtect (TRUE);
    54     dvo_catalog_save (&catalog, VERBOSE);
     54    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     55    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
    5556    SetProtect (FALSE);
    56     dvo_catalog_unlock (&catalog);
     57
    5758    dvo_catalog_free (&catalog);
    5859  }

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

    r38471 r38986  
    1212
    1313  // need to construct these options with args_load2mass...
     14  SetSignals ();
    1415  options = ConfigInit (&argc, argv);
    1516  options = args_sedstar (argc, argv, options);
    … …  
    6465    SEDfitCatalog (&outcatalog, &incatalog, sedtable);
    6566   
    66     dvo_catalog_save (&outcatalog, VERBOSE);
    67     dvo_catalog_unlock (&outcatalog);
     67    SetProtect (TRUE);
     68    if (!dvo_catalog_save (&outcatalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", outcatalog.filename); exit (1); }
     69    if (!dvo_catalog_unlock (&outcatalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", outcatalog.filename); exit (1); }
     70    SetProtect (FALSE);
    6871    dvo_catalog_free (&outcatalog);
    6972

  • trunk/Ohana/src/addstar/test

  • trunk/Ohana/src/delstar/src/Shutdown.c

    r35758 r38986  
    2121  va_end (argp);
    2222
    23   SetProtect (TRUE);
    24   if (db) gfits_db_close (db);
    2523  fprintf (stderr, "ERROR: delstar halted\n");
    2624  exit (1);

  • trunk/Ohana/src/delstar/src/delete_duplicate_images.c

    r38471 r38986  
    131131
    132132    if (UPDATE) {
     133      SetProtect (TRUE);
    133134      dvo_catalog_save_complete (&catalog, VERBOSE2);
    134135    }
    135 
    136136    dvo_catalog_unlock (&catalog);
     137    SetProtect (FALSE);
     138
    137139    dvo_catalog_free (&catalog);
    138140  }

  • trunk/Ohana/src/delstar/src/delete_duplicate_measures.c

    r38471 r38986  
    6666      // skip if nothing was deleted
    6767      if (UPDATE) {
    68         if (!dvo_catalog_backup (&catalog, TRUE)) {
     68        if (!dvo_catalog_backup (&catalog, "~", TRUE)) {
    6969          fprintf (stderr, "ERROR: failed to make backup for catalog %s\n", catalog.filename);
    7070          exit (1);
    7171        }
     72        SetProtect (TRUE);
    7273        dvo_catalog_save_complete (&catalog, VERBOSE2);
    7374      }
    7475    }
    75 
    7676    dvo_catalog_unlock (&catalog);
     77    SetProtect (FALSE);
     78
    7779    dvo_catalog_free (&catalog);
    7880  }

  • trunk/Ohana/src/delstar/src/delete_fix_LAP.c

    r38471 r38986  
    6868    int noChange = (NaverageStart == catalog.Naverage) && (NmeasureStart == catalog.Nmeasure);
    6969    if (UPDATE && !noChange) {
     70      SetProtect (TRUE);
    7071      dvo_catalog_save_complete (&catalog, VERBOSE2);
    7172    }
    72 
    7373    dvo_catalog_unlock (&catalog);
     74    SetProtect (FALSE);
     75
    7476    dvo_catalog_free (&catalog);
    7577  }

  • trunk/Ohana/src/delstar/src/delete_fix_LAP_edges_delete.c

    r38471 r38986  
    117117    if (UPDATE && !noChange) {
    118118      // XXX save a backup copy first
    119       // dvo_catalog_backup (&catalog, TRUE);
     119      // dvo_catalog_backup (&catalog, "~", TRUE);
     120      SetProtect (TRUE);
    120121      dvo_catalog_save_complete (&catalog, VERBOSE2);
    121122    }
    122 
    123123    dvo_catalog_unlock (&catalog);
     124    SetProtect (FALSE);
     125
    124126    dvo_catalog_free (&catalog);
    125127  }

  • trunk/Ohana/src/delstar/src/delete_imagefile.c

    r38471 r38986  
    4848    find_matches (&catalog, image[0].photcode, start, stop);
    4949
    50     dvo_catalog_save (&catalog, VERBOSE);
    51     dvo_catalog_unlock (&catalog);
     50    SetProtect (TRUE);
     51    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     52    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     53    SetProtect (FALSE);
    5254    dvo_catalog_free (&catalog);
    5355  }

  • trunk/Ohana/src/delstar/src/delete_imagename.c

    r38471 r38986  
    6262      find_matches (&catalog, image[j].photcode, start, stop);
    6363
     64      SetProtect (TRUE);
    6465      dvo_catalog_save_complete (&catalog, VERBOSE);
    6566      dvo_catalog_unlock (&catalog);
     67      SetProtect (FALSE);
    6668      dvo_catalog_free (&catalog);
    6769    }

  • trunk/Ohana/src/delstar/src/delete_photcodes.c

    r38471 r38986  
    6060
    6161    delete_photcodes_catalog (&catalog, photcodes, Nphotcodes);
     62    SetProtect (TRUE);
    6263    dvo_catalog_save_complete (&catalog, VERBOSE2);
    6364    dvo_catalog_unlock (&catalog);
     65    SetProtect (FALSE);
    6466    dvo_catalog_free (&catalog);
    6567  }

  • trunk/Ohana/src/delstar/src/delete_photcodes_single.c

    r38471 r38986  
    2828
    2929  delete_photcodes_catalog (&catalog, photcodes, Nphotcodes);
     30  SetProtect (TRUE);
    3031  dvo_catalog_save_complete (&catalog, VERBOSE2);
    3132  dvo_catalog_unlock (&catalog);
     33  SetProtect (FALSE);
    3234  dvo_catalog_free (&catalog);
    3335  return TRUE;

  • trunk/Ohana/src/delstar/src/delete_times.c

    r38471 r38986  
    7777
    7878    find_matches (&catalog, code, START, END);
    79     dvo_catalog_save (&catalog, VERBOSE);
    80     dvo_catalog_unlock (&catalog);
     79    SetProtect (TRUE);
     80    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     81    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     82    SetProtect (FALSE);
    8183    dvo_catalog_free (&catalog);
    8284  }

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

    r38153 r38986  
    6868int           main                    PROTO((int argc, char **argv));
    6969
    70 void          update_objects          PROTO(());
     70void          update_objects          PROTO((void));
    7171int           update_objects_parallel PROTO((SkyList *sky));
    7272int           update_objects_catalog  PROTO((Catalog *catalog));

  • trunk/Ohana/src/dvolens/src/dvolens.c

    r37358 r38986  
    44
    55  // get configuration info, args
     6  SetSignals ();
    67  DvoLensMode mode = initialize (argc, argv);
    78  if (!mode) exit (2);

  • trunk/Ohana/src/dvolens/src/update_objects.c

    r38471 r38986  
    9494
    9595    SetProtect (TRUE);
    96     dvo_catalog_save (&catalog, VERBOSE);
    97     dvo_catalog_unlock (&catalog);
     96    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     97    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
    9898    SetProtect (FALSE);
    9999

  • trunk/Ohana/src/dvomerge/Makefile

    r38468 r38986  
    4040$(SRC)/dvo_image_merge_dbs.$(ARCH).o \
    4141$(SRC)/IDmapIO.$(ARCH).o \
     42$(SRC)/ConfigInit.$(ARCH).o \
    4243$(SRC)/SetSignals.$(ARCH).o \
    43 $(SRC)/ConfigInit.$(ARCH).o \
    4444$(SRC)/Shutdown.$(ARCH).o \
    4545$(SRC)/help.$(ARCH).o \
    … …  
    5151$(SRC)/replace_match.$(ARCH).o \
    5252$(SRC)/replace_tycho.$(ARCH).o \
     53$(SRC)/repair_catalog_by_objID.$(ARCH).o \
    5354$(SRC)/merge_catalogs_new.$(ARCH).o \
    5455$(SRC)/merge_catalogs_old.$(ARCH).o
    … …  
    7576$(SRC)/replace_match.$(ARCH).o \
    7677$(SRC)/replace_tycho.$(ARCH).o \
     78$(SRC)/repair_catalog_by_objID.$(ARCH).o \
    7779$(SRC)/merge_catalogs_new.$(ARCH).o \
    7880$(SRC)/merge_catalogs_old.$(ARCH).o
    … …  
    122124$(SRC)/dvorepair.$(ARCH).o \
    123125$(SRC)/dvorepairFixCPT.$(ARCH).o \
     126$(SRC)/dvorepairFixWarpIDs.$(ARCH).o \
    124127$(SRC)/dvorepairImagesVsMeasures.$(ARCH).o \
    125128$(SRC)/dvorepairDeleteImageList.$(ARCH).o \
    … …  
    127130$(SRC)/dvorepairDeleteImagesByExternID.$(ARCH).o \
    128131$(SRC)/dvorepairFixImages.$(ARCH).o \
     132$(SRC)/dvorepair_by_objID.$(ARCH).o \
     133$(SRC)/repair_catalog_by_objID.$(ARCH).o \
    129134$(SRC)/psps_ids.$(ARCH).o \
    130135$(SRC)/LoadImages.$(ARCH).o \
    131136$(SRC)/ReadDeleteList.$(ARCH).o \
    132137$(SRC)/ReadDeleteListExternID.$(ARCH).o \
     138$(SRC)/SetSignals.$(ARCH).o \
     139$(SRC)/Shutdown.$(ARCH).o \
    133140$(SRC)/myIndex.$(ARCH).o \
    134141$(SRC)/match_image.$(ARCH).o \
    … …  
    140147
    141148DVOVERIFY = \
     149$(SRC)/SetSignals.$(ARCH).o \
     150$(SRC)/Shutdown.$(ARCH).o \
    142151$(SRC)/dvoverify.$(ARCH).o \
    143152$(SRC)/dvoverify_args.$(ARCH).o \
    … …  
    149158
    150159DVOVERIFY_CLIENT = \
     160$(SRC)/SetSignals.$(ARCH).o \
     161$(SRC)/Shutdown.$(ARCH).o \
    151162$(SRC)/dvoverify_client.$(ARCH).o \
    152163$(SRC)/dvoverify_args.$(ARCH).o \
    … …  
    158169
    159170DVOUTILS = \
     171$(SRC)/SetSignals.$(ARCH).o \
     172$(SRC)/Shutdown.$(ARCH).o \
    160173$(SRC)/dvoutils.$(ARCH).o \
    161174$(SRC)/dvoutils_args.$(ARCH).o \

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

    r38553 r38986  
    4747
    4848int    MATCHED_TABLES;
     49int    REPAIR_BY_OBJID;
    4950
    5051char *SINGLE_CPT;
    … …  
    202203int        dvomergeUpdate_catalogs PROTO((char *input, char *output, SkyTable *outsky, SkyList *inlist, int NsecfiltInput, int NsecfiltOutput, IDmapType *IDmap, int *secfiltMap));
    203204
    204 int        replace_match           PROTO((Average *average_out, Measure *measure_out, Average *average_in, Measure *measure_in));
     205int        replace_match           PROTO((Average *average_out, Measure *measure_out, off_t *next_meas, Average *average_in, Measure *measure_in));
    205206
    206207int        IDmapSave               PROTO((char *filename, IDmapType *IDmap));
    … …  
    241242
    242243void replace_tycho_init ();
    243 int  replace_tycho (Average *averageInp, Measure *measureInp, Average *averageOut, Measure *measureOut);
     244int  replace_tycho (Average *averageInp, Measure *measureInp, off_t *next_meas, Average *averageOut, Measure *measureOut);
     245int repair_catalog_by_objID (Catalog *catalog);
     246
     247int dvorepair_by_objID (int argc, char **argv);
     248int dvorepairFixWarpIDs (int argc, char **argv);
     249

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

    r37807 r38986  
    2222} DVOUTILS_OP_TYPE;
    2323
     24typedef struct {
     25  int   *externID;
     26  short *photcode;
     27  int Nimages;
     28} ImageData;
     29
    2430int VERBOSE;
    2531int DVOUTILS_OP;
    … …  
    3036int dvoutils_args (int *argc, char **argv);
    3137int dvoutils_uniq_images (char *filename);
    32 int *dvoutils_load_image_index (char *filename, int *nindex);
     38
     39ImageData *dvoutils_load_image_index (char *filename);
    3340
    3441Image *dvoutils_load_image_table (char *filename, int *nimage);
     42
     43int        SetSignals             PROTO((void));
     44void       SetProtect             PROTO((int mode));
     45void       TrapSignal             PROTO((int sig));
     46int        Shutdown               PROTO((char *format, ...)) OHANA_FORMAT(printf, 1, 2);
     47

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

    r38553 r38986  
    3737int    LIST_MISSING;
    3838
     39int    IGNORE_SORTED_STATE;
     40
    3941SkyRegion UserPatch;
    4042
    … …  
    6264
    6365void FreeImageIDs (void);
     66
     67int        SetSignals             PROTO((void));
     68void       SetProtect             PROTO((int mode));
     69void       TrapSignal             PROTO((int sig));
     70int        Shutdown               PROTO((char *format, ...)) OHANA_FORMAT(printf, 1, 2);
     71

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

    r38471 r38986  
    99
    1010  // always load all of the data (if any exists)
    11   catalog[0].catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT | DVO_LOAD_LENSING | DVO_LOAD_LENSOBJ | DVO_LOAD_STARPAR | DVO_LOAD_GALPHOT;
     11  // XXXX TEMP HACK : skip GALPHOT
     12  // XXXX catalog[0].catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT | DVO_LOAD_LENSING | DVO_LOAD_LENSOBJ | DVO_LOAD_STARPAR | DVO_LOAD_GALPHOT;
     13  catalog[0].catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT | DVO_LOAD_LENSING | DVO_LOAD_LENSOBJ | DVO_LOAD_STARPAR;
    1214 
    1315  catalog[0].catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data

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

    r37807 r38986  
    4747      // confirm we have 9 fields broken by 8 spaces:
    4848      space = c0; // pointer to track the space-separated words
    49       indexPoint = c0; // pointer to the ID on this line
     49      indexPoint = strchr(c0, ' '); // pointer to the ID on this line
    5050
    51       for (j = 0; j < 8; j++) {
     51      for (j = 0; j < 9; j++) {
    5252        space = strchr(space, ' ');
    5353        if (!space) {
    … …  
    6262      indexList[Nindex] = index;
    6363
    64       // fprintf (stderr, "index: %d, line: %s\n", index, c0);
     64      fprintf (stderr, "index: %d, line: %s\n", index, c0);
    6565
    6666      Nindex ++;

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

    r38553 r38986  
    9494  if ((N = get_argument (*argc, argv, "-replace-tycho"))) {
    9595    REPLACE_TYCHO = TRUE;
     96    remove_argument (N, argc, argv);
     97  }
     98
     99  REPAIR_BY_OBJID = FALSE;
     100  if ((N = get_argument (*argc, argv, "-repair-by-objid"))) {
     101    REPAIR_BY_OBJID = TRUE;
    96102    remove_argument (N, argc, argv);
    97103  }
    … …  
    266272  }
    267273
     274  REPAIR_BY_OBJID = FALSE;
     275  if ((N = get_argument (*argc, argv, "-repair-by-objid"))) {
     276    REPAIR_BY_OBJID = TRUE;
     277    remove_argument (N, argc, argv);
     278  }
     279
    268280  NTHREADS = 0;
    269281  if ((N = get_argument (*argc, argv, "-threads"))) {

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

    r37814 r38986  
    145145    n = average[i].measureOffset;
    146146    average[i].measureOffset = N;
     147    int myObjID = average[i].objID;
    147148    for (k = 0; k < average[i].Nmeasure; k++, N++) {
    148149      if (n == -1) abort();
    149150      tmpmeasure[N] = measure[n];
    150       if (measure[n].averef != i) abort();
     151      myAssert (measure[n].averef == i, "error in averef?");
     152      myAssert (measure[n].objID == myObjID, "error in objID?");
    151153      tmpmeasure[N].averef = i;
    152154      n = next_meas[n];

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

    r38441 r38986  
    9494
    9595    outcatalog.catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT;
     96
     97    SetProtect (TRUE);
     98    if (!dvo_catalog_save (&outcatalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", outcatalog.filename); exit (1); }
     99    if (!dvo_catalog_unlock (&outcatalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", outcatalog.filename); exit (1); }
     100    SetProtect (FALSE);
     101
    96102    dvo_catalog_save (&outcatalog, VERBOSE);
    97103    dvo_catalog_unlock (&outcatalog);

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

    r38441 r38986  
    133133      // if we receive a signal which would cause us to exit, wait until the full catalog is written
    134134      SetProtect (TRUE);
    135       if (!dvo_catalog_save (&outcatalog, VERBOSE)) {
    136         fprintf (stderr, "ERROR: failed to save catalog %s\n", outlist[0].filename[j]);
    137         exit (1);
    138       }
     135      if (!dvo_catalog_save (&outcatalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", outcatalog.filename); exit (1); }
     136      if (!dvo_catalog_unlock (&outcatalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", outcatalog.filename); exit (1); }
    139137      SetProtect (FALSE);
    140138
    141       dvo_catalog_unlock (&outcatalog);
    142139      dvo_catalog_free (&outcatalog);
    143140

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

    r38441 r38986  
    7777      SetProtect (TRUE);
    7878      if (!dvo_catalog_save (&outcatalog, VERBOSE)) {
    79         fprintf (stderr, "ERROR: failed to save catalog %s\n", outlist[0].filename[j]);
     79        fprintf (stderr, "ERROR: failed to save catalog %s\n", outcatalog.filename);
     80        threadData->state = TS_FAIL;
     81        continue;
     82      }
     83      if (!dvo_catalog_unlock (&outcatalog)) {
     84        fprintf (stderr, "ERROR: failed to unlock catalog %s\n", outcatalog.filename);
    8085        threadData->state = TS_FAIL;
    8186        continue;
    … …  
    8388      SetProtect (FALSE);
    8489
    85       dvo_catalog_unlock (&outcatalog);
    8690      dvo_catalog_free (&outcatalog);
    8791

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

    r38441 r38986  
    178178    SkyListFree (inlist);
    179179
    180     dvo_catalog_save (&outcatalog, VERBOSE);
    181     dvo_catalog_unlock (&outcatalog);
     180    SetProtect (TRUE);
     181    if (!dvo_catalog_save (&outcatalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", outcatalog.filename); exit (1); }
     182    if (!dvo_catalog_unlock (&outcatalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", outcatalog.filename); exit (1); }
     183    SetProtect (FALSE);
     184
    182185    dvo_catalog_free (&outcatalog);
    183186  }

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

    r38441 r38986  
    147147    // if we receive a signal which would cause us to exit, wait until the full catalog is written
    148148    SetProtect (TRUE);
    149     if (!dvo_catalog_save (&outcatalog, VERBOSE)) {
    150       fprintf (stderr, "ERROR: failed to save catalog %s\n", outputfile);
    151       exit (1);
    152     }
     149    if (!dvo_catalog_save (&outcatalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save catalog %s\n", outcatalog.filename); exit (1); }
     150    if (!dvo_catalog_unlock (&outcatalog)) { fprintf (stderr, "ERROR: failed to unlock catalog %s\n", outcatalog.filename); exit (1); }
    153151    SetProtect (FALSE);
    154152   
    … …  
    158156    OutputStatusFree (outstat, 1);
    159157
    160     dvo_catalog_unlock (&outcatalog);
    161158    dvo_catalog_free (&outcatalog);
    162159   

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

    r38470 r38986  
    177177      LoadCatalog (&outcatalog, outlist[0].regions[j], outcatalog.filename, "w", NsecfiltOutput);
    178178
    179       // if no catalog already exists, use the input catalog to define the format or the specified format
    180179      if (UPDATE_CATFORMAT) {
    181180        outcatalog.catformat = dvo_catalog_catformat (UPDATE_CATFORMAT);
    182181      } else {
    183         outcatalog.catformat = incatalog.catformat;
    184       }
     182        // IF no catalog already exists, use the input catalog to define the format
     183        if (outcatalog.Naverage_disk == 0) {
     184          outcatalog.catformat = incatalog.catformat;
     185        }
     186      }
     187
    185188      if (UPDATE_CATCOMPRESS) {
    186189        outcatalog.catcompress = dvo_catalog_catcompress (UPDATE_CATCOMPRESS);
    187190      } else {
    188         outcatalog.catcompress = incatalog.catcompress;
     191        // IF no catalog already exists, use the input catalog to define the compression
     192        if (outcatalog.Naverage_disk == 0) {
     193          outcatalog.catcompress = incatalog.catcompress;
     194        }
     195      }
     196
     197      if (REPAIR_BY_OBJID) {
     198        // For gpc1 / PV3, I broke some catalogs with dvomerge -replace: the last object can
     199        // contaminate the first set of new measurements
     200        repair_catalog_by_objID (&outcatalog);
    189201      }
    190202
    … …  
    195207      }
    196208
    197       if (!dvo_catalog_backup (&outcatalog, TRUE)) {
     209      if (!dvo_catalog_backup (&outcatalog, "~", TRUE)) {
    198210        fprintf (stderr, "ERROR: failed to make backup for catalog %s\n", outlist[0].filename[j]);
    199211        exit (1);
    … …  
    202214      // if we receive a signal which would cause us to exit, wait until the full catalog is written
    203215      SetProtect (TRUE);
    204       if (!dvo_catalog_save (&outcatalog, VERBOSE)) {
    205         fprintf (stderr, "ERROR: failed to save catalog %s\n", outlist[0].filename[j]);
    206         exit (1);
    207       }
     216      if (!dvo_catalog_save (&outcatalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save catalog %s\n", outcatalog.filename); exit (1); }
     217      if (!dvo_catalog_unlock (&outcatalog)) { fprintf (stderr, "ERROR: failed to unlock catalog %s\n", outcatalog.filename); exit (1); }
    208218      SetProtect (FALSE);
    209219
    210       if (!dvo_catalog_unlock (&outcatalog)) {
    211         fprintf (stderr, "ERROR: failed to unlock catalog %s\n", outlist[0].filename[j]);
    212         exit (1);
    213       }
    214 
    215       if (!dvo_catalog_unlink_backup (&outcatalog, TRUE)) {
     220      if (!dvo_catalog_unlink_backup (&outcatalog, "~", TRUE)) {
    216221        fprintf (stderr, "WARNING: failed to remove backup for catalog %s\n", outlist[0].filename[j]);
    217222      }
    … …  
    282287
    283288    // options / arguments that can affect relastro_client -update-objects:
    284     char command[DVO_MAX_PATH];
    285     snprintf (command, DVO_MAX_PATH, "dvomerge_client %s into %s -hostID %d -hostdir %s -region %f %f %f %f -D ADDSTAR_RADIUS %f",
    286               absinput, absoutput, group->hosts[i][0].hostID, group->hosts[i][0].pathname,
    287               UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, RADIUS
    288       );
    289 
    290     char tmpline[DVO_MAX_PATH];
    291     if (VERBOSE)             { snprintf (tmpline, DVO_MAX_PATH, "%s -v",                command); strcpy (command, tmpline); }
    292     if (VERIFY)              { snprintf (tmpline, DVO_MAX_PATH, "%s -verify",           command); strcpy (command, tmpline); }
    293     if (VERIFY_CATALOG_ONLY) { snprintf (tmpline, DVO_MAX_PATH, "%s -verify-catalogs",  command); strcpy (command, tmpline); }
    294     if (REPLACE_BY_PHOTCODE) { snprintf (tmpline, DVO_MAX_PATH, "%s -replace",          command); strcpy (command, tmpline); }
    295     if (REPLACE_TYCHO)       { snprintf (tmpline, DVO_MAX_PATH, "%s -replace-tycho",    command); strcpy (command, tmpline); }
    296     if (PARALLEL_INPUT)      { snprintf (tmpline, DVO_MAX_PATH, "%s -parallel-input",   command); strcpy (command, tmpline); }
    297     if (FORCE_MERGE)         { snprintf (tmpline, DVO_MAX_PATH, "%s -force-merge",      command); strcpy (command, tmpline); }
    298     if (MATCHED_TABLES)      { snprintf (tmpline, DVO_MAX_PATH, "%s -matched-tables",   command); strcpy (command, tmpline); }
    299     if (UPDATE_CATFORMAT)    { snprintf (tmpline, DVO_MAX_PATH, "%s -update-catformat %s", command, UPDATE_CATFORMAT); strcpy (command, tmpline); }
     289    char *command = NULL;
     290    strextend (&command, "dvomerge_client %s into %s -hostID %d -hostdir %s -region %f %f %f %f -D ADDSTAR_RADIUS %f",
     291               absinput, absoutput, group->hosts[i][0].hostID, group->hosts[i][0].pathname,
     292               UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, RADIUS);
     293
     294    if (VERBOSE)             { strextend (&command, "-v"); }
     295    if (VERIFY)              { strextend (&command, "-verify"); }
     296    if (VERIFY_CATALOG_ONLY) { strextend (&command, "-verify-catalogs"); }
     297    if (REPLACE_BY_PHOTCODE) { strextend (&command, "-replace"); }
     298    if (REPLACE_TYCHO)       { strextend (&command, "-replace-tycho"); }
     299    if (PARALLEL_INPUT)      { strextend (&command, "-parallel-input"); }
     300    if (FORCE_MERGE)         { strextend (&command, "-force-merge"); }
     301    if (MATCHED_TABLES)      { strextend (&command, "-matched-tables"); }
     302    if (UPDATE_CATFORMAT)    { strextend (&command, "-update-catformat %s", UPDATE_CATFORMAT); }
     303    if (UPDATE_CATCOMPRESS)  { strextend (&command, "-update-catcompress %s", UPDATE_CATCOMPRESS); }
     304    if (REPAIR_BY_OBJID)     { strextend (&command, "-repair-by-objid"); }
    300305
    301306    // add some config variables:
    302     snprintf (tmpline, DVO_MAX_PATH, "%s -D CATMODE %s",    command, CATMODE);   strcpy (command, tmpline);
    303     snprintf (tmpline, DVO_MAX_PATH, "%s -D CATFORMAT %s",  command, CATFORMAT); strcpy (command, tmpline);
    304     snprintf (tmpline, DVO_MAX_PATH, "%s -D SKY_DEPTH %d",  command, SKY_DEPTH); strcpy (command, tmpline);
     307    strextend (&command, "-D CATMODE %s", CATMODE);
     308    strextend (&command, "-D CATFORMAT %s", CATFORMAT);
     309    strextend (&command, "-D SKY_DEPTH %d", SKY_DEPTH);
    305310
    306311    fprintf (stderr, "command: %s\n", command);

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

    r38441 r38986  
    7575      SetProtect (TRUE);
    7676      if (!dvo_catalog_save (&outcatalog, VERBOSE)) {
    77         fprintf (stderr, "ERROR: failed to save catalog %s\n", outlist[0].filename[j]);
     77        fprintf (stderr, "ERROR: failed to save catalog %s\n", outcatalog.filename);
     78        threadData->state = TS_FAIL;
     79        continue;
     80      }
     81      if (!dvo_catalog_unlock (&outcatalog)) {
     82        fprintf (stderr, "ERROR: failed to save catalog %s\n", outcatalog.filename);
    7883        threadData->state = TS_FAIL;
    7984        continue;
    … …  
    8186      SetProtect (FALSE);
    8287
    83       dvo_catalog_unlock (&outcatalog);
    8488      dvo_catalog_free (&outcatalog);
    8589

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

    r35818 r38986  
    33int main (int argc, char **argv) {
    44
     5  SetSignals ();
    56  dvomerge_client_help (argc, argv);
    67  ConfigInit (&argc, argv);
    … …  
    8384  // loop over the populatable output tables; check for data in input in the corresponding regions
    8485
    85   SetPhotcodeTable(NULL);
    86  
     86  if (REPLACE_TYCHO) replace_tycho_init();
     87
    8788  dvomergeUpdate_catalogs (input, output, outsky, inlist, NsecfiltInput, NsecfiltOutput, IDmap, secfiltMap);
    8889

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

    r37807 r38986  
    77  // exit (2);
    88
     9  SetSignals ();
    910  dvorepair_help(argc, argv);
    1011 
     12  if (!strcmp(argv[1], "-fix-warp-ids")) dvorepairFixWarpIDs(argc, argv);
     13
    1114  if (!strcmp(argv[1], "-fix-cpt")) dvorepairFixCPT(argc, argv);
     15  if (!strcmp(argv[1], "-fix-cpt-by-objID")) dvorepair_by_objID(argc, argv);
    1216  // if (!strcmp(argv[1], "-fix-tables")) dvorepairFixTables(argc, argv);
    1317  if (!strcmp(argv[1], "-images-vs-measures")) dvorepairImagesVsMeasures(argc, argv);

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

    r38441 r38986  
    3939    exit (2);
    4040  }
     41
     42  SetSignals ();
    4143
    4244  imageFilename  = argv[1];

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

    r38468 r38986  
    1616int SaveImageTable (Image *image, off_t Nimage, char *catdir, FITS_DB *oldDB);
    1717Image *DeleteSelectedImages (Image *image, off_t Nimage, int *deleteImage, myIndexType *imageIDindex, off_t *NnewImage);
     18int DeleteLensing (Catalog *catalog, myIndexType *imageIDindex, int *deleteImage, int *nDelete);
     19int DeleteMeasure (Catalog *catalog, myIndexType *imageIDindex, int *deleteImage, int *nDelete);
     20int RepairAverage (Catalog *catalog);
    1821
    1922int dvorepairDeleteImagesByExternID (int argc, char **argv) {
    … …  
    2124  FITS_DB db;  // database handle pointing to input image table
    2225 
    23   int i, j, N, NmeasureNew, Ndelete, Nvalid;
    24   off_t Nimage, Nmeasure;
     26  int i, N;
     27  off_t Nimage;
    2528  int nPass, raPass;
    2629
    2730  Image *image;
    28   Measure *measure;
    29   Measure *measureNew;
    30 
    31   char *cpmFilenameSrc = NULL;
    32   char *cptFilenameSrc = NULL;
    33   char *cpsFilenameSrc = NULL;
    34   char *cpmFilenameTgt = NULL;
    35   char *cptFilenameTgt = NULL;
    36   char *cpsFilenameTgt = NULL;
    37 
    3831  char *imageFilename = NULL;
    39 
    40   DVOCatFormat catformat;
     32  char filename[DVO_MAX_PATH];
    4133
    4234  N = get_argument (argc, argv, "-delete-images-by-extern-id");
    … …  
    5951  char *catdir = argv[1];
    6052  char *delList = argv[2];
     53
     54  sprintf (filename, "%s/Photcodes.dat", catdir);
     55  if (!LoadPhotcodes (filename, NULL, FALSE)) {
     56    fprintf (stderr, "error reading photcodes from %s\n", catdir);
     57    exit (1);
     58  }     
    6159
    6260  // load the image data
    … …  
    196194  }
    197195 
    198   ALLOCATE(cpmFilenameSrc, char, strlen(catdir) + 64);
    199   ALLOCATE(cptFilenameSrc, char, strlen(catdir) + 64);
    200   ALLOCATE(cpsFilenameSrc, char, strlen(catdir) + 64);
    201   ALLOCATE(cpmFilenameTgt, char, strlen(catdir) + 64);
    202   ALLOCATE(cptFilenameTgt, char, strlen(catdir) + 64);
    203   ALLOCATE(cpsFilenameTgt, char, strlen(catdir) + 64);
    204 
    205   int NdeleteTotal = 0;
     196  int NmeasureDelTotal = 0;
     197  int NlensingDelTotal = 0;
    206198
    207199  for (raPass = 0; raPass < nPass; raPass++) {
    … …  
    231223 
    232224    // loop over the populated input regions
    233     int Ncheck = 0;
    234225    for (i = 0; i < inlist[0].Nregions; i++) {
    235226      if (!inlist[0].regions[i][0].table) continue;
    236227
    237       sprintf (cpmFilenameSrc, "%s/%s.cpm", catdir, inlist[0].regions[i][0].name);
    238       sprintf (cptFilenameSrc, "%s/%s.cpt", catdir, inlist[0].regions[i][0].name);
    239       sprintf (cpsFilenameSrc, "%s/%s.cps", catdir, inlist[0].regions[i][0].name);
    240       sprintf (cpmFilenameTgt, "%s/%s.cpm.broken", catdir, inlist[0].regions[i][0].name);
    241       sprintf (cptFilenameTgt, "%s/%s.cpt.broken", catdir, inlist[0].regions[i][0].name);
    242       sprintf (cpsFilenameTgt, "%s/%s.cps.broken", catdir, inlist[0].regions[i][0].name);
    243 
    244       Header cpmHeaderPHU;
    245       Header cpmHeaderTBL;
    246       FTable cpmFtable;
    247 
    248       /*** read and examine the CPM file ***/
    249       {
    250         if (VERBOSE) fprintf (stderr, "check %s\n", cpmFilenameSrc);
    251 
    252         cpmFtable.header = &cpmHeaderTBL;
    253 
    254         // open cpm file
    255         FILE *cpmFile = fopen(cpmFilenameSrc, "r");
    256         if (!cpmFile) continue;
    257         // myAssert(cpmFile, "failed to open cpm file");
    258    
    259         // load the cpm header
    260         if (!gfits_fread_header (cpmFile, &cpmHeaderPHU)) {
    261           myAbort("failure to cpm header");
    262         }
    263 
    264         // move to TBL header
    265         int Nbytes = cpmHeaderPHU.datasize + gfits_data_size (&cpmHeaderPHU);
    266         fseeko (cpmFile, Nbytes, SEEK_SET);
    267 
    268         // read cpm TBL header
    269         if (!gfits_fread_header (cpmFile, &cpmHeaderTBL)) {
    270           myAbort("can't read header for cpm table");
    271         }
    272 
    273         // read Measure table data : format is irrelevant here */
    274         if (!gfits_fread_ftable_data (cpmFile, &cpmFtable, TRUE)) {
    275           myAbort("can't read data for cpm table");
    276         }
    277 
    278         int NbytesPerRow;
    279         gfits_scan(&cpmHeaderTBL, "NAXIS1", "%d", 1, &NbytesPerRow);
    280 
    281         myAbort ("fix compression");
    282 
    283         // this function can only handle PS1_V5 and later formats
    284         // NOTE: FtableToMeasure (and equivalent) free the data associated with cpmFtable.
    285         // We are left with the data in measure.
    286         measure = FtableToMeasure (&cpmFtable, NULL, &Nmeasure, &catformat, FALSE);
    287         myAssert(measure, "failed to convert ftable to measure data");
    288    
    289         Nvalid = (int)(cpmFtable.validsize / NbytesPerRow);
    290         Nvalid = MIN(Nmeasure, Nvalid);
    291 
    292         // close the input cpm file
    293         fclose(cpmFile);
    294 
    295         // allocate an output array of measures (to replace, if needed)
    296         ALLOCATE (measureNew, Measure, Nvalid);
    297 
    298         NmeasureNew = 0;
    299         Ndelete = 0;
    300 
    301         // examine all measurements: find ones that need to be deleted
    302         for (j = 0; j < Nvalid; j++) {
    303           int imageID = measure[j].imageID;
    304           myAssert(imageID, "measure is missing an image ID");
    305           // XXX this case is valid if we have REF detections (no associated image)
    306 
    307           int N = myIndexGetEntry(imageIDindex, imageID);
    308           if (N < 0) {
    309             // this detection comes from a non-existant image, delete
    310             Ndelete ++;
    311             continue;
    312           }
    313 
    314           if (deleteImage[N]) {
    315             Ndelete ++;
    316             continue;
    317           }
    318           measureNew[NmeasureNew] = measure[j];
    319           NmeasureNew ++;
    320         }
     228      snprintf (filename, DVO_MAX_PATH, "%s/%s.cpt", catdir, inlist[0].regions[i][0].name);
     229
     230      Catalog catalog;
     231
     232      // set up the basic catalog info
     233      dvo_catalog_init (&catalog, TRUE);
     234      catalog.filename  = filename; // XXX only allow non-parallel dbs for now
     235      catalog.catflags  = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_SECFILT | DVO_LOAD_LENSING;
     236      catalog.Nsecfilt  = GetPhotcodeNsecfilt ();
     237     
     238      if (!dvo_catalog_open (&catalog, inlist[0].regions[i], VERBOSE, "w")) {
     239        fprintf (stderr, "ERROR: failure reading catalog %s\n", catalog.filename);
     240        exit (1);
    321241      }
    322 
    323       NdeleteTotal += Ndelete;
    324 
    325       // if we actually want to delete any measurements, write out a new cpm file
    326       if (Ndelete > 0) {
    327 
    328         fprintf (stderr, "deleting %d of %d (keep %d) detections from %s -> %s\n", (int) Ndelete, (int) Nvalid, (int) NmeasureNew, cpmFilenameSrc, cpmFilenameTgt);
     242      if (!catalog.Naverage_disk) {
     243        if (VERBOSE) fprintf (stderr, "no data in %s, skipping\n", catalog.filename);
     244        dvo_catalog_unlock (&catalog);
     245        dvo_catalog_free (&catalog);
     246        continue;
     247      }
    329248     
    330         // the CPT and CPS tables need to be regenerated.  This must happen first because, in the process, we also update measure->averef
    331         // what about other tables?
    332         RepairTableCPT_V1(cptFilenameSrc, cptFilenameTgt, cpsFilenameSrc, cpsFilenameTgt, measureNew, NmeasureNew, image, Nimage, imageIDindex, catformat);
    333 
    334         // convert internal to external format
    335         if (!MeasureToFtable (&cpmFtable, NULL, measureNew, NmeasureNew, catformat, TRUE)) {
    336           myAbort("trouble converting format");
    337         }
    338 
    339         // rename the old cpm file:
    340         if (rename (cpmFilenameSrc, cpmFilenameTgt)) {
    341           perror ("tried to rename file");
    342           exit (2);
    343         }
    344 
    345         // create and write the output file
    346         FILE *cpmFile = fopen(cpmFilenameSrc, "w");
    347         myAssert(cpmFile, "failed to open cpt file");
    348        
    349         // write PHU header
    350         if (!gfits_fwrite_header (cpmFile, &cpmHeaderPHU)) {
    351           myAbort("can't write primary header");
    352         }
    353 
    354         Matrix matrix;
    355 
    356         // write the PHU matrix; this is probably a NOP, do I have to keep it in?
    357         gfits_create_matrix (&cpmHeaderPHU, &matrix);
    358         if (!gfits_fwrite_matrix  (cpmFile, &matrix)) {
    359           myAbort("can't write primary matrix");
    360         }
    361         gfits_free_matrix (&matrix);
    362        
    363         // write the table data
    364         if (!gfits_fwrite_ftable_range (cpmFile, &cpmFtable, 0, NmeasureNew, 0, NmeasureNew)) {
    365           myAbort("can't write table data");
    366         }
    367         fclose (cpmFile);
    368 
    369         gfits_free_table (&cpmFtable);
    370       } else {
    371         if (VERBOSE) fprintf (stderr, "nothing to delete in %s\n", cpmFilenameSrc);
     249      /*** delete the measure and lensing entries matching the list of imageIDs ***/
     250      int NmeasureDel = 0;
     251      DeleteMeasure (&catalog, imageIDindex, deleteImage, &NmeasureDel);
     252
     253      int NlensingDel = 0;
     254      DeleteLensing (&catalog, imageIDindex, deleteImage, &NlensingDel);
     255
     256      fprintf (stderr, "deleting %d measure, %d lensing (keep %d, %d)\n", NmeasureDel, NlensingDel, (int) catalog.Nmeasure, (int) catalog.Nlensing);
     257
     258      if (!NmeasureDel && !NlensingDel) {
     259        if (VERBOSE) fprintf (stderr, "nothing to delete in %s\n", catalog.filename);
     260        dvo_catalog_unlock (&catalog);
     261        dvo_catalog_free (&catalog);
     262        continue;
    372263      }
    373264
    374       gfits_free_header (&cpmHeaderPHU);
    375       gfits_free_header (&cpmHeaderTBL);
    376       free (measure);
    377       free (measureNew);
    378 
    379       Ncheck ++;
    380       if (Ncheck % 1000 == 0) {
    381         fprintf (stderr, "%s...", inlist[0].regions[i][0].name);
     265      NmeasureDelTotal += NmeasureDel;
     266      NlensingDelTotal += NlensingDel;
     267
     268      // the CPT and CPS tables need to be regenerated.  This must happen first because, in the process, we also update measure->averef
     269      // what about other tables?
     270      RepairAverage (&catalog);
     271
     272      if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
     273     
     274      if (!dvo_catalog_backup (&catalog, ".undel", TRUE)) {
     275        fprintf (stderr, "ERROR: failed to make backup for catalog %s\n", catalog.filename);
     276        exit (1);
    382277      }
     278
     279      SetProtect (TRUE);
     280      if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     281      if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     282      SetProtect (FALSE);
     283      dvo_catalog_free (&catalog);
    383284    }
    384285    fprintf (stderr, "\n");
    … …  
    386287  }
    387288
    388   fprintf (stderr, "Deleted %d detections\n", NdeleteTotal);
     289  fprintf (stderr, "Deleted %d measure, %d lensing detections\n", NmeasureDelTotal, NlensingDelTotal);
    389290
    390291  off_t NnewImage;
    … …  
    400301  free (deleteIDs);
    401302
    402   free(cpmFilenameSrc);
    403   free(cptFilenameSrc);
    404   free(cpsFilenameSrc);
    405   free(cpmFilenameTgt);
    406   free(cptFilenameTgt);
    407   free(cpsFilenameTgt);
    408 
    409303  SkyTableFree(insky);
    410304
    411305  gfits_db_free (&db);
     306
     307  ohana_memcheck (TRUE);
    412308
    413309  exit (0);
    … …  
    661557  gfits_scan (&cptHeaderPHU, "NSECFILT",     "%d",      1,  &Nsecfilt);
    662558
    663   myAbort ("test for compression");
     559  if (0) {
     560    char compressMode[256];
     561    if (gfits_scan (&cptHeaderTBL, "DVO_CMP", "%s", 1, compressMode)) {
     562      if (strcmp (compressMode, "NONE")) {
     563        myAbort ("fix compression");
     564      }
     565    }
     566  }
    664567
    665568  /* convert internal to external format */
    … …  
    774677}
    775678
     679int RepairAverage (Catalog *catalog) {
     680
     681  off_t i, j, Nave;
     682
     683  // average is sorted so averef is valid
     684  // secfilt is also sorted so sequence is valid (but this is kind of moot since it will be re-calculated)
     685  // average.measureOffset is NOT valid
     686  // average.lensingOffset is NOT valid
     687
     688  Average *average = catalog->average;
     689  Measure *measure = catalog->measure;
     690  Lensing *lensing = catalog->lensing;
     691 
     692  // reset the values of average.Nmeasure, average.Nlensing
     693  for (i = 0; i < catalog->Naverage; i++) {
     694    average[i].Nmeasure = 0;
     695    average[i].Nlensing = 0;
     696  }
     697
     698  // re-calculate average.Nmeasure
     699  for (i = 0; i < catalog->Nmeasure; i++) {
     700    Nave = measure[i].averef;
     701    myAssert (measure[i].objID == average[Nave].objID, "invalid measure:average match");
     702    average[Nave].Nmeasure ++;
     703  }
     704   
     705  // re-calculate average.Nlensing
     706  for (i = 0; i < catalog->Nlensing; i++) {
     707    Nave = lensing[i].averef;
     708    myAssert (lensing[i].objID == average[Nave].objID, "invalid lensing:average match");
     709    average[Nave].Nlensing ++;
     710  }
     711
     712  // create a copy of the average table, keeping only the entries with Nmeasure & Nlensing > 0
     713  ALLOCATE_PTR (averageNew, Average, catalog->Naverage);
     714  ALLOCATE_PTR (averefNew,  int,     catalog->Naverage);
     715
     716  Nave = 0;
     717  for (i = 0; i < catalog->Naverage; i++) {
     718    averefNew[i] = -1;
     719    if (!average[i].Nmeasure && !average[i].Nlensing) continue;
     720
     721    averageNew[Nave] = average[i];
     722    averefNew[i] = Nave;
     723    Nave ++;
     724  }
     725  off_t NaverageNew = Nave;
     726
     727  // update measure.averef values
     728  for (i = 0; i < catalog->Nmeasure; i++) {
     729    Nave = averefNew[measure[i].averef];
     730    myAssert (Nave >= 0, "oops");
     731    measure[i].averef = Nave;
     732  }
     733   
     734  // update lensing.averef values
     735  for (i = 0; i < catalog->Nlensing; i++) {
     736    Nave = averefNew[lensing[i].averef];
     737    myAssert (Nave >= 0, "oops");
     738    lensing[i].averef = Nave;
     739  }
     740 
     741  // XXX need to update measureOffset and lensingOffset
     742
     743  // measure[] should be blocked and sequential:
     744  // measure[i+1].averef >= measure[i].averef
     745
     746  // update average.measureOffset values
     747  Nave = -1;
     748  for (i = 0; i < catalog->Nmeasure; i++) {
     749    if (measure[i].averef == Nave) continue;
     750    Nave = measure[i].averef;
     751    averageNew[Nave].measureOffset = i;
     752  }
     753
     754  // update average.lensingOffset values
     755  Nave = -1;
     756  for (i = 0; i < catalog->Nlensing; i++) {
     757    if (lensing[i].averef == Nave) continue;
     758    Nave = lensing[i].averef;
     759    averageNew[Nave].lensingOffset = i;
     760  }
     761
     762  // check the result (measure -> average)
     763  for (i = 0; i < catalog->Nmeasure; i++) {
     764    Nave = measure[i].averef;
     765    myAssert(averageNew[Nave].objID == measure[i].objID, "objIDs do not match");
     766    myAssert(averageNew[Nave].catID == measure[i].catID, "catIDs do not match");
     767  }
     768  // check the result (average -> measure)
     769  for (i = 0; i < NaverageNew; i++) {
     770    int m = averageNew[i].measureOffset;
     771    for (j = 0; j < averageNew[i].Nmeasure; j++) {
     772      myAssert(averageNew[i].objID == measure[j+m].objID, "objIDs do not match");
     773      myAssert(averageNew[i].catID == measure[j+m].catID, "catIDs do not match");
     774      myAssert(measure[j+m].averef == i, "averef broken");
     775    }
     776  }
     777
     778  // check the result (lensing -> average)
     779  for (i = 0; i < catalog->Nlensing; i++) {
     780    Nave = lensing[i].averef;
     781    myAssert(averageNew[Nave].objID == lensing[i].objID, "objIDs do not match");
     782    myAssert(averageNew[Nave].catID == lensing[i].catID, "catIDs do not match");
     783  }
     784  // check the result (average -> lensing)
     785  for (i = 0; i < NaverageNew; i++) {
     786    int m = averageNew[i].lensingOffset;
     787    for (j = 0; j < averageNew[i].Nlensing; j++) {
     788      myAssert(averageNew[i].objID == lensing[j+m].objID, "objIDs do not match");
     789      myAssert(averageNew[i].catID == lensing[j+m].catID, "catIDs do not match");
     790      myAssert(lensing[j+m].averef == i, "averef broken");
     791    }
     792  }
     793
     794  free (catalog->secfilt);
     795  ALLOCATE (catalog->secfilt, SecFilt, NaverageNew*catalog->Nsecfilt);
     796  for (i = 0; i < NaverageNew*catalog->Nsecfilt; i++) {
     797    dvo_secfilt_init (&catalog->secfilt[i], SECFILT_RESET_ALL);
     798  }
     799
     800  free (averefNew);
     801  free (catalog->average);
     802  catalog->average = averageNew;
     803  catalog->Naverage = NaverageNew;
     804  catalog->Naverage_disk = NaverageNew;
     805
     806  catalog->Nsecfilt_disk = NaverageNew*catalog->Nsecfilt;
     807
     808  return (TRUE);
     809}
     810
     811// delete measure entries
     812int DeleteMeasure (Catalog *catalog, myIndexType *imageIDindex, int *deleteImage, int *nDelete) {
     813
     814  int j;
     815
     816  Measure *measure = catalog->measure;
     817
     818  // allocate an output array of measures (to replace, if needed)
     819  ALLOCATE_PTR (measureNew, Measure, catalog->Nmeasure);
     820
     821  int NmeasureNew = 0;
     822  int NmeasureDel = 0;
     823
     824  // examine all measurements: find ones that need to be deleted
     825  for (j = 0; j < catalog->Nmeasure; j++) {
     826    int imageID = measure[j].imageID;
     827    myAssert(imageID, "measure is missing an image ID");
     828    // XXX this case is valid if we have REF detections (no associated image)
     829
     830    int N = myIndexGetEntry(imageIDindex, imageID);
     831    if (N < 0) {
     832      // this detection comes from a non-existant image; delete
     833      NmeasureDel ++;
     834      continue;
     835    }
     836
     837    // measure matches a bad image; delete
     838    if (deleteImage[N]) {
     839      NmeasureDel ++;
     840      continue;
     841    }
     842
     843    // keep this measure
     844    measureNew[NmeasureNew] = measure[j];
     845    NmeasureNew ++;
     846  }
     847
     848  free (catalog->measure);
     849  catalog->measure = measureNew;
     850  catalog->Nmeasure = NmeasureNew;
     851  catalog->Nmeasure_disk = NmeasureNew;
     852
     853  *nDelete = NmeasureDel;
     854
     855  return TRUE;
     856}
     857
     858// delete lensing entries
     859int DeleteLensing (Catalog *catalog, myIndexType *imageIDindex, int *deleteImage, int *nDelete) {
     860
     861  int j;
     862
     863  Lensing *lensing = catalog->lensing;
     864
     865  // allocate an output array of measures (to replace, if needed)
     866  ALLOCATE_PTR (lensingNew, Lensing, catalog->Nlensing);
     867
     868  int NlensingNew = 0;
     869  int NlensingDel = 0;
     870
     871  // examine all lensingments: find ones that need to be deleted
     872  for (j = 0; j < catalog->Nlensing; j++) {
     873    int imageID = lensing[j].imageID;
     874    myAssert(imageID, "lensing is missing an image ID");
     875    // XXX this case is valid if we have REF detections (no associated image)
     876
     877    int N = myIndexGetEntry(imageIDindex, imageID);
     878    if (N < 0) {
     879      // this detection comes from a non-existant image; delete
     880      NlensingDel ++;
     881      continue;
     882    }
     883
     884    // lensing matches a bad image; delete
     885    if (deleteImage[N]) {
     886      NlensingDel ++;
     887      continue;
     888    }
     889
     890    // keep this lensing
     891    lensingNew[NlensingNew] = lensing[j];
     892    NlensingNew ++;
     893  }
     894
     895  free (catalog->lensing);
     896  catalog->lensing = lensingNew;
     897  catalog->Nlensing = NlensingNew;
     898  catalog->Nlensing_disk = NlensingNew;
     899
     900  *nDelete = NlensingDel;
     901
     902  return TRUE;
     903}
     904

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

    r38441 r38986  
    255255
    256256  /* setup image table format and lock */
    257   gfits_db_init (oldDB);
     257  gfits_db_init (&db);
    258258  db.mode   = oldDB->mode;
    259259  db.format = oldDB->format;
    … …  
    266266  /* load or create the image table */
    267267  myAssert (db.dbstate == LCK_EMPTY, "do not overwrite exiting image table");
    268   myAssert (db.format == DVO_FORMAT_PS1_V2, "format mismatch");
     268  // myAssert (db.format == DVO_FORMAT_PS1_V2, "format mismatch");
    269269
    270270  dvo_image_create (&db, GetZeroPoint());
     271  gfits_copy_header (&oldDB->header, &db.header);
    271272 
    272273  // replace the existing buffer with the image array
    … …  
    277278  nbytes = gfits_data_size (db.ftable.header);
    278279  db.ftable.datasize = nbytes;
    279   db.ftable.buffer = (char *) imageOut;
    280   REALLOCATE (db.ftable.buffer, char, MAX (nbytes, 1));
     280
     281  free (db.ftable.buffer);
     282  ALLOCATE (db.ftable.buffer, char, MAX (nbytes, 1));
     283  memcpy (db.ftable.buffer, imageOut, nbytes);
    281284  memset (&db.ftable.buffer[Nx*Nout], ' ', nbytes - Nx*Nout);
    282285
    … …  
    295298  dvo_image_unlock (&db);
    296299
     300  gfits_db_free (&db);
     301
    297302  return TRUE;
    298303}

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

    r38441 r38986  
    3939  }
    4040
     41  SetSignals ();
    4142  catdir = argv[1];
    4243  Ntol = atoi(argv[2]);

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

    r38471 r38986  
    8282    catalog.Nsecfilt_disk = Nsecfilt * catalog.Naverage_disk;
    8383
    84     dvo_catalog_save (&catalog, VERBOSE);
    85     dvo_catalog_unlock (&catalog);
     84    SetProtect (TRUE);
     85    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     86    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     87    SetProtect (FALSE);
     88
    8689    dvo_catalog_free (&catalog);
    8790  }

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

    r37807 r38986  
    44
    55  // check various options
     6  SetSignals ();
    67  dvoutils_args (&argc, argv);
    78

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

    r38441 r38986  
    22
    33// load the array of EXTERN_ID from the ImageIndex.fits tables
    4 int *dvoutils_load_image_index (char *filename, int *nindex) {
     4ImageData *dvoutils_load_image_index (char *filename) {
    55
    66  int Ncol;
    7   off_t Nrow;
     7  off_t Nrow, Nphot;
    88  Header header;
    99  Header theader;
    … …  
    4646  fclose (f);
    4747
    48   int *externID = gfits_get_bintable_column_data (&theader, &ftable, "EXTERN_ID", type, &Nrow, &Ncol);
     48  ImageData *imdata = NULL;
     49  ALLOCATE (imdata, ImageData, 1);
     50
     51  imdata->externID = gfits_get_bintable_column_data (&theader, &ftable, "EXTERN_ID", type, &Nrow, &Ncol);
    4952  myAssert (!strcmp(type, "int"), "wrong column type");
     53
     54  imdata->photcode = gfits_get_bintable_column_data (&theader, &ftable, "PHOTCODE", type, &Nphot, &Ncol);
     55  myAssert (Nphot == Nrow, "photcode & extern_id mis-match");
     56
     57  imdata->Nimages = Nrow;
    5058
    5159  gfits_free_header (&header);
    … …  
    5462  gfits_free_table  (&ftable);
    5563
    56   *nindex = Nrow;
    57 
    58   return externID;
     64  return imdata;
    5965}
    6066

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

    r38441 r38986  
    4040    }
    4141
    42     int Nimage;
    43     // Image *image = dvoutils_load_image_table (imFile, &Nimage);
    44     int *extern_id = dvoutils_load_image_index (imFile, &Nimage);
    45     if (!extern_id) continue;
     42    ImageData *imdata = dvoutils_load_image_index (imFile);
     43    if (!imdata) continue;
    4644
    4745    DBlist[Ndb] = strcreate (imFile);
    … …  
    5755
    5856    int i;
    59     for (i = 0; i < Nimage; i++) {
    60       if (!extern_id[i]) continue;
    61       myMaxID = MAX(extern_id[i], myMaxID);
    62       myMinID = MIN(extern_id[i], myMinID);
     57    int Nbad = 0;
     58    for (i = 0; i < imdata->Nimages; i++) {
     59      if (!imdata->photcode[i] && imdata->externID[i]) myAbort ("invalid combo");
     60
     61      if (!imdata->photcode[i]) continue;
     62      if (!imdata->externID[i]) {
     63        Nbad ++;
     64        continue;
     65      }
     66      myMaxID = MAX(imdata->externID[i], myMaxID);
     67      myMinID = MIN(imdata->externID[i], myMinID);
    6368    }
    6469
    65     fprintf (stderr, "read %s, %d images, %d - %d vs %d - %d\n", imFile, (int) Nimage, myMinID, myMaxID, minID, maxID);
     70    fprintf (stderr, "read %s, %d images, %d - %d vs %d - %d\n", imFile, (int) imdata->Nimages, myMinID, myMaxID, minID, maxID);
     71
     72    if (Nbad) {
     73      fprintf (stderr, "WARNING: %d images without extern_id set\n", (int) Nbad);
     74    }
    6675
    6776    // if this is new, we treat it a bit differently
    … …  
    124133    }
    125134
    126     for (i = 0; i < Nimage; i++) {
    127       if (!extern_id[i]) continue;
    128       int n = extern_id[i] - minID;
     135    for (i = 0; i < imdata->Nimages; i++) {
     136      if (!imdata->externID[i]) continue;
     137      int n = imdata->externID[i] - minID;
    129138      if (IDlist[n] == 0) {
    130139        DBfound[n] = Ndb;
    … …  
    133142      IDlist[n] ++;
    134143      if (VERBOSE && (IDlist[n] > 1)) {
    135         fprintf (stderr, "duplicate ext_id %d in file %s\n", extern_id[i], imFile);
     144        fprintf (stderr, "duplicate ext_id %d in file %s\n", imdata->externID[i], imFile);
    136145      }
    137146    }
    … …  
    140149      fprintf (stderr, "------------ %s ----------\n", imFile);
    141150
    142       for (i = 0; i < Nimage; i++) {
    143         if (!extern_id[i]) continue;
    144         fprintf (stderr, "%d => %d\n", extern_id[i], extern_id[i] - minID);
     151      for (i = 0; i < imdata->Nimages; i++) {
     152        if (!imdata->externID[i]) continue;
     153        fprintf (stderr, "%d => %d\n", imdata->externID[i], imdata->externID[i] - minID);
    145154      }
    146155
    … …  
    165174    int n = DBfound[i];
    166175    myAssert (n > -1, "impossible!");
    167     fprintf (stdout, "%d : %d -- in %s (%d) : %d \n", i + minID, IDlist[i], DBlist[n], DBfound[i], DBindex[i]);
     176    fprintf (stdout, "primary %d : %d -- in %s (%d) : %d \n", i + minID, IDlist[i], DBlist[n], DBfound[i], DBindex[i]);
    168177  }
    169178

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

    r38553 r38986  
    1414
    1515  // check various options
     16  SetSignals ();
    1617  dvoverify_args (&argc, argv);
    1718  CATDIR = argv[1];
    … …  
    7879  SkyListFree (skylist);
    7980
    80   ohana_memcheck (TRUE);
    81   ohana_memdump (TRUE);
     81  ohana_memcheck (VERBOSE);
     82  ohana_memdump (VERBOSE);
    8283  exit (0);
    8384}

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

    r38553 r38986  
    2424  if ((N = get_argument (*argc, argv, "-sorted"))) {
    2525    CHECKSORTED = TRUE;
     26    remove_argument (N, argc, argv);
     27  }
     28
     29  // in some cases, the header sorted state can claim F but is actually T
     30  IGNORE_SORTED_STATE = FALSE;
     31  if ((N = get_argument (*argc, argv, "-ignore-sorted-state"))) {
     32    IGNORE_SORTED_STATE = TRUE;
    2633    remove_argument (N, argc, argv);
    2734  }
    … …  
    5057    free (filename);
    5158
    52     ohana_memcheck (TRUE);
    53     ohana_memdump (TRUE);
     59    ohana_memcheck (VERBOSE);
     60    ohana_memdump (VERBOSE);
    5461
    5562    if (!isGood) exit (1);
    … …  
    204211  }
    205212
     213  // in some cases, the header sorted state can claim F but is actually T
     214  IGNORE_SORTED_STATE = FALSE;
     215  if ((N = get_argument (*argc, argv, "-ignore-sorted-state"))) {
     216    IGNORE_SORTED_STATE = TRUE;
     217    remove_argument (N, argc, argv);
     218  }
     219
    206220  if (!HOST_ID || !HOSTDIR || (*argc != 2)) {
    207221    fprintf (stderr, "USAGE: dvoverify_client (catdir) -results (file) -hostID ID -hostdir DIR [-region Rmin Rmax Dmin Dmax] [-v] [-s]\n\n");

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

    r38553 r38986  
    117117
    118118    // options / arguments that can affect relastro_client -update-objects:
    119     char command[DVO_MAX_PATH];
    120     snprintf (command, DVO_MAX_PATH, "dvoverify_client %s -results %s -hostID %d -hostdir %s -region %f %f %f %f",
    121               abscatdir, table->hosts[i].results, table->hosts[i].hostID, table->hosts[i].pathname,
    122               UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax
    123       );
     119    char *command = NULL;
     120    strextend (&command, "dvoverify_client %s -results %s -hostID %d -hostdir %s -region %f %f %f %f",
     121               abscatdir, table->hosts[i].results, table->hosts[i].hostID, table->hosts[i].pathname,
     122               UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
    124123
    125     char tmpline[DVO_MAX_PATH];
    126     if (VERBOSE)         { snprintf (tmpline, DVO_MAX_PATH, "%s -v", command); strcpy (command, tmpline); }
    127     if (CHECKSORTED)     { snprintf (tmpline, DVO_MAX_PATH, "%s -s", command); strcpy (command, tmpline); }
    128     if (!CHECK_IMAGE_ID) { snprintf (tmpline, DVO_MAX_PATH, "%s -skip-image-ids", command); strcpy (command, tmpline); }
    129     if (LIST_MISSING)    { snprintf (tmpline, DVO_MAX_PATH, "%s -list-missing", command); strcpy (command, tmpline); }
     124    if (VERBOSE)             { strextend (&command, "-v"); }
     125    if (CHECKSORTED)         { strextend (&command, "-s"); }
     126    if (IGNORE_SORTED_STATE) { strextend (&command, "-ignore-sorted-state"); }
     127    if (!CHECK_IMAGE_ID)     { strextend (&command, "-skip-image-ids"); }
     128    if (LIST_MISSING)        { strextend (&command, "-list-missing"); }
    130129
    131130    fprintf (stderr, "command: %s\n", command);
    … …  
    149148      table->hosts[i].pid = pid; // save for future reference
    150149    }
     150    free (command);
    151151  }
    152152

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

    r37360 r38986  
    88
    99  // check various options
     10  SetSignals ();
    1011  dvoverify_client_args (&argc, argv);
    1112  CATDIR = argv[1];

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

    r38553 r38986  
    188188  dvo_catalog_init (&catalog, TRUE);
    189189  catalog.filename  = filename;
    190   catalog.catflags  = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_LENSING | DVO_LOAD_LENSOBJ;
     190  catalog.catflags  = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_LENSING | DVO_LOAD_LENSOBJ | DVO_LOAD_STARPAR | DVO_LOAD_GALPHOT;
    191191  catalog.Nsecfilt  = 0;
    192192 
    … …  
    214214
    215215  // if the table is NOT SORTED, do we have a subset of checks we can make?
    216   if (!catalog.sorted) {
     216  if (!catalog.sorted && !IGNORE_SORTED_STATE) {
    217217    fprintf (stderr, "!");
    218218    dvo_catalog_unlock (&catalog);
    … …  
    222222    return TRUE;
    223223  }
    224 
    225   int NmeasureTotal = 0;
    226   int measureOffsetOK = TRUE;
    227   int NlensingTotal = 0;
    228   int lensingOffsetOK = TRUE;
    229   int NlensobjTotal = 0;
    230   int lensobjOffsetOK = TRUE;
    231   for (i = 0; i < catalog.Naverage; i++) {
    232     NmeasureTotal += catalog.average[i].Nmeasure;
    233     if (VERBOSE && !(NmeasureTotal <= catalog.Nmeasure)) {
    234       fprintf (stderr, "NmeasureTotal > catalog.Nmeasure: %d %d %d\n", i, catalog.average[i].Nmeasure, (int) catalog.Nmeasure);
    235     }
    236     measureOffsetOK &= (catalog.average[i].measureOffset < catalog.Nmeasure);
    237     if (VERBOSE && !(catalog.average[i].measureOffset < catalog.Nmeasure)) {
    238       fprintf (stderr, "measureOffset >= catalog.Nmeasure: %d %d %d\n", i, catalog.average[i].measureOffset, (int) catalog.Nmeasure);
    239     }
    240     measureOffsetOK &= (catalog.average[i].measureOffset + catalog.average[i].Nmeasure <= catalog.Nmeasure);
    241     if (VERBOSE && !(catalog.average[i].measureOffset + catalog.average[i].Nmeasure <= catalog.Nmeasure)) {
    242       fprintf (stderr, "measureOffset + Nmeasure > catalog.Nmeasure : %d %d %d\n", i, catalog.average[i].Nmeasure, (int) catalog.Nmeasure);
    243     }
    244 
    245     // sum of Nlensing for each object < Nlensing for catalog
    246     NlensingTotal += catalog.average[i].Nlensing;
    247     if (VERBOSE && !(NlensingTotal <= catalog.Nlensing)) {
    248       fprintf (stderr, "NlensingTotal > catalog.Nlensing: %d %d %d\n", i, catalog.average[i].Nlensing, (int) catalog.Nlensing);
    249     }
    250     // lensingOffset needs to be in range for each object
    251     lensingOffsetOK &= (!catalog.Nlensing || (catalog.average[i].lensingOffset < catalog.Nlensing));
    252     if (VERBOSE && catalog.Nlensing && !(catalog.average[i].lensingOffset < catalog.Nlensing)) {
    253       fprintf (stderr, "lensingOffset >= catalog.Nlensing: %d %d %d\n", i, catalog.average[i].lensingOffset, (int) catalog.Nlensing);
    254     }
    255     lensingOffsetOK &= (catalog.average[i].lensingOffset + catalog.average[i].Nlensing <= catalog.Nlensing);
    256     if (VERBOSE && !(catalog.average[i].lensingOffset + catalog.average[i].Nlensing <= catalog.Nlensing)) {
    257       fprintf (stderr, "lensingOffset + Nlensing > catalog.Nlensing : %d %d %d\n", i, catalog.average[i].Nlensing, (int) catalog.Nlensing);
    258     }
    259 
    260     NlensobjTotal += catalog.average[i].Nlensobj;
    261     if (VERBOSE && !(NlensobjTotal <= catalog.Nlensobj)) {
    262       fprintf (stderr, "NlensobjTotal > catalog.Nlensobj: %d %d %d\n", i, catalog.average[i].Nlensobj, (int) catalog.Nlensobj);
    263     }
    264     lensobjOffsetOK &= (catalog.average[i].lensobjOffset < catalog.Nlensobj);
    265     if (VERBOSE && !(catalog.average[i].lensobjOffset < catalog.Nlensobj)) {
    266       fprintf (stderr, "lensobjOffset >= catalog.Nlensobj: %d %d %d\n", i, catalog.average[i].lensobjOffset, (int) catalog.Nlensobj);
    267     }
    268     lensobjOffsetOK &= (catalog.average[i].lensobjOffset + catalog.average[i].Nlensobj <= catalog.Nlensobj);
    269     if (VERBOSE && !(catalog.average[i].lensobjOffset + catalog.average[i].Nlensobj <= catalog.Nlensobj)) {
    270       fprintf (stderr, "lensobjOffset + Nlensobj > catalog.Nlensobj : %d %d %d\n", i, catalog.average[i].Nlensobj, (int) catalog.Nlensobj);
    271     }
    272   }
    273 
    274   if (!measureOffsetOK) {
    275     fprintf (stderr, "ERROR: catalog %s has an invalid measureOffset\n", catalog.filename);
    276     status = FALSE;
    277   }
    278 
    279   if (NmeasureTotal != catalog.Nmeasure) {
    280     fprintf (stderr, "ERROR: catalog %s has an invalid Nmeasure\n", catalog.filename);
    281     status = FALSE;
    282   }
    283 
    284   if (!lensingOffsetOK) {
    285     fprintf (stderr, "ERROR: catalog %s has an invalid lensingOffset\n", catalog.filename);
    286     status = FALSE;
    287   }
    288 
    289   if (NlensingTotal != catalog.Nlensing) {
    290     fprintf (stderr, "ERROR: catalog %s has an invalid Nlensing\n", catalog.filename);
    291     status = FALSE;
    292   }
    293 
    294   if (!lensobjOffsetOK) {
    295     fprintf (stderr, "ERROR: catalog %s has an invalid lensobjOffset\n", catalog.filename);
    296     status = FALSE;
    297   }
    298 
    299   if (NlensobjTotal != catalog.Nlensobj) {
    300     fprintf (stderr, "ERROR: catalog %s has an invalid Nlensobj\n", catalog.filename);
    301     status = FALSE;
    302   }
     224 
     225# define CHECK_TABLE(NAME) {                                            \
     226    int Ntotal = 0; int offsetOK = TRUE; int isOK = FALSE;              \
     227    for (i = 0; i < catalog.Naverage; i++) {                            \
     228      Ntotal += catalog.average[i].N##NAME;                             \
     229      if (VERBOSE && !(Ntotal <= catalog.N##NAME)) {                    \
     230        fprintf (stderr, "Ntotal (%s) > catalog.N##NAME: %d %d : %d > %d\n", #NAME, i, Ntotal, catalog.average[i].N##NAME, (int) catalog.N##NAME); \
     231      }                                                                 \
     232      isOK = (catalog.average[i].N##NAME == 0) || (catalog.average[i].NAME##Offset < catalog.N##NAME); \
     233      offsetOK &= isOK;                                                 \
     234      if (VERBOSE && !isOK) {                                           \
     235        fprintf (stderr, "%sOffset >= catalog.N%s: %d : %d >= %d\n", #NAME, #NAME, i, catalog.average[i].NAME##Offset, (int) catalog.N##NAME); \
     236      }                                                                 \
     237      isOK = (catalog.average[i].N##NAME == 0) || (catalog.average[i].NAME##Offset + catalog.average[i].N##NAME <= catalog.N##NAME); \
     238      offsetOK &= isOK;                                                 \
     239      if (VERBOSE && !isOK) {                                           \
     240        fprintf (stderr, "%sOffset + N%s > catalog.N%s : %d : %d + %d > %d\n", #NAME, #NAME, #NAME, i, catalog.average[i].N##NAME, catalog.average[i].NAME##Offset, (int) catalog.N##NAME); \
     241      } }                                                               \
     242    if (!offsetOK) {                                                    \
     243      fprintf (stderr, "ERROR: catalog %s has an invalid %sOffset\n", catalog.filename, #NAME); \
     244      status = FALSE;                                                   \
     245    }                                                                   \
     246    if (Ntotal != catalog.N##NAME) {                                    \
     247      fprintf (stderr, "ERROR: catalog %s has an invalid N%s\n", catalog.filename, #NAME); \
     248      status = FALSE;                                                   \
     249    }                                                                   \
     250  }
     251 
     252  CHECK_TABLE(measure);
     253  CHECK_TABLE(lensing);
     254  CHECK_TABLE(lensobj);
     255  CHECK_TABLE(starpar);
     256  CHECK_TABLE(galphot);
    303257
    304258  // if we have a problem with Nmeasure and/or measureOffset values, we
    … …  
    312266  // check measure <-> average links
    313267  {
    314     int objIDsOK = TRUE;
    315     int catIDsOK = TRUE;
    316     int averefOK = TRUE;
     268    int NobjIDsBAD = 0;
     269    int NcatIDsBAD = 0;
     270    int NaverefBAD = 0;
    317271
    318272    for (i = 0; i < catalog.Naverage; i++) {
    319273      m = catalog.average[i].measureOffset;
    320274      for (j = 0; j < catalog.average[i].Nmeasure; j++) {
    321         objIDsOK &= (catalog.average[i].objID == catalog.measure[m+j].objID);
    322         catIDsOK &= (catalog.average[i].catID == catalog.measure[m+j].catID);
    323         averefOK &= (catalog.measure[m+j].averef == i);
     275        if (catalog.average[i].objID != catalog.measure[m+j].objID) {
     276          NobjIDsBAD ++;
     277
     278          // check if objID matches R,D
     279          Measure *measure = &catalog.measure[m+j];
     280          int iTest = measure->objID;
     281          if (catalog.average[iTest].objID == iTest) {
     282            double dR = 3600.0*(catalog.average[iTest].R - measure->R) * cos (RAD_DEG*measure->D);
     283            double dD = 3600.0*(catalog.average[iTest].D - measure->D);
     284            double dRad = hypot (dR, dD);
     285            char *date = ohana_sec_to_date (measure->t);
     286            fprintf (stderr, "matches ave %d = %d, %s : %6.3f %5d : %f, %f = %f\n", iTest, measure->objID, date, measure->M, measure->photcode, dR, dD, dRad);
     287            free (date);
     288          } else {
     289            fprintf (stderr, "cannot find averef\n");
     290          }
     291        }
     292        if (catalog.average[i].catID != catalog.measure[m+j].catID) {
     293          NcatIDsBAD ++;
     294        }
     295        if (catalog.measure[m+j].averef != i) {
     296          NaverefBAD ++;
     297        }
    324298      }
    325299    }
    326300   
    327     if (!objIDsOK) {
    328       fprintf (stderr, "ERROR: catalog %s has invalid obj IDs\n", catalog.filename);
    329       status = FALSE;
    330     }
    331     if (!catIDsOK) {
    332       fprintf (stderr, "ERROR: catalog %s has invalid cat IDs\n", catalog.filename);
    333       status = FALSE;
    334     }
    335     if (!averefOK) {
    336       fprintf (stderr, "ERROR: catalog %s has invalid averef values\n", catalog.filename);
     301    if (NobjIDsBAD) {
     302      fprintf (stderr, "ERROR: catalog %s has %d invalid obj IDs\n", catalog.filename, NobjIDsBAD);
     303      status = FALSE;
     304    }
     305    if (NcatIDsBAD) {
     306      fprintf (stderr, "ERROR: catalog %s has %d invalid cat IDs\n", catalog.filename, NcatIDsBAD);
     307      status = FALSE;
     308    }
     309    if (NaverefBAD) {
     310      fprintf (stderr, "ERROR: catalog %s has %d invalid averef values\n", catalog.filename, NaverefBAD);
    337311      status = FALSE;
    338312    }
    … …  
    387361    if (!catIDsOK) {
    388362      fprintf (stderr, "ERROR: catalog %s has invalid lensobj cat IDs\n", catalog.filename);
     363      status = FALSE;
     364    }
     365  }
     366
     367  // check starpar <-> average links
     368  {
     369    int objIDsOK = TRUE;
     370    int catIDsOK = TRUE;
     371    int averefOK = TRUE;
     372
     373    for (i = 0; i < catalog.Naverage; i++) {
     374      m = catalog.average[i].starparOffset;
     375      for (j = 0; j < catalog.average[i].Nstarpar; j++) {
     376        objIDsOK &= (catalog.average[i].objID == catalog.starpar[m+j].objID);
     377        catIDsOK &= (catalog.average[i].catID == catalog.starpar[m+j].catID);
     378        averefOK &= (catalog.starpar[m+j].averef == i);
     379      }
     380    }
     381   
     382    if (!objIDsOK) {
     383      fprintf (stderr, "ERROR: catalog %s has invalid starpar obj IDs\n", catalog.filename);
     384      status = FALSE;
     385    }
     386    if (!catIDsOK) {
     387      fprintf (stderr, "ERROR: catalog %s has invalid starpar cat IDs\n", catalog.filename);
     388      status = FALSE;
     389    }
     390    if (!averefOK) {
     391      fprintf (stderr, "ERROR: catalog %s has invalid starpar averef values\n", catalog.filename);
     392      status = FALSE;
     393    }
     394  }
     395
     396  // check galphot <-> average links
     397  {
     398    int objIDsOK = TRUE;
     399    int catIDsOK = TRUE;
     400    int averefOK = TRUE;
     401
     402    for (i = 0; i < catalog.Naverage; i++) {
     403      m = catalog.average[i].galphotOffset;
     404      for (j = 0; j < catalog.average[i].Ngalphot; j++) {
     405        objIDsOK &= (catalog.average[i].objID == catalog.galphot[m+j].objID);
     406        catIDsOK &= (catalog.average[i].catID == catalog.galphot[m+j].catID);
     407        averefOK &= (catalog.galphot[m+j].averef == i);
     408      }
     409    }
     410   
     411    if (!objIDsOK) {
     412      fprintf (stderr, "ERROR: catalog %s has invalid galphot obj IDs\n", catalog.filename);
     413      status = FALSE;
     414    }
     415    if (!catIDsOK) {
     416      fprintf (stderr, "ERROR: catalog %s has invalid galphot cat IDs\n", catalog.filename);
     417      status = FALSE;
     418    }
     419    if (!averefOK) {
     420      fprintf (stderr, "ERROR: catalog %s has invalid galphot averef values\n", catalog.filename);
    389421      status = FALSE;
    390422    }

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

    r35590 r38986  
    172172
    173173  fprintf (stderr, "USAGE\n");
     174  fprintf (stderr, "  dvorepair -fix-warp-ids (catdir) (idfile) - regenerate images.dat warp_skyfile_ids (EXTERN_ID) values\n");
    174175  fprintf (stderr, "  dvorepair -fix-cpt (images) (rootlist) - regenerate cpt & cps files from the cpm files\n");
    175176  fprintf (stderr, "  dvorepair -images-vs-measures (catdir) (Ntol) - find images with too many missing detections\n");

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

    r38468 r38986  
    198198    int Nreplace = 0;
    199199    if (REPLACE_TYCHO) {
    200       int Mout = output[0].average[n].measureOffset; 
    201200      int Minp =  input[0].average[N].measureOffset;
    202       Nreplace = replace_tycho (&output[0].average[n], &output[0].measure[Mout], &input[0].average[N], &input[0].measure[Minp]);
     201      Nreplace = replace_tycho (&output[0].average[n], output[0].measure, next_meas, &input[0].average[N], &input[0].measure[Minp]);
    203202      if (Nreplace == 6) {
    204203        input[0].found_t[N] = Nmeas;
    … …  
    216215        // index to first measure for this object
    217216        // XXX this does not support lensing measurements
    218         int Mout = output[0].average[n].measureOffset; 
    219         if (replace_match(&output[0].average[n], &output[0].measure[Mout], &input[0].average[N], &input[0].measure[offset])) {
    220           input[0].found_t[N] = Mout;
     217        if (replace_match (&output[0].average[n], output[0].measure, next_meas, &input[0].average[N], &input[0].measure[offset])) {
     218          input[0].found_t[N] = output[0].average[n].measureOffset; 
    221219          continue;
    222220        }

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

    r37046 r38986  
    11# include "dvomerge.h"
    22
     3// XXX this function does not work because it it loops over the average->Nmeasure entries
     4// as if they were sorted, but objects which have had entries added to them have elements
     5// out of sequence.  I probably need to step through next_meas to find the sequence.
     6
    37// average and measure pointers to the objects of interest and their first / current measurement
    4 int replace_match (Average *average_out, Measure *measure_out, Average *average_in, Measure *measure_in) {
     8int replace_match (Average *average_out, Measure *measure_out, off_t *next_meas, Average *average_in, Measure *measure_in) {
    59
    610  int Nout;
    … …  
    812  unsigned int catID;
    913
     14  off_t m = average_out->measureOffset;
     15
    1016  // find the matching photcode in the object's list of measurements
    1117  for (Nout = 0; Nout < average_out[0].Nmeasure; Nout ++) {
    12     if (measure_out[Nout].photcode != measure_in[0].photcode) continue;
     18    myAssert (m > -1, "oops");
     19    if (measure_out[m].photcode != measure_in[0].photcode) {
     20      m = next_meas[m];
     21      continue;
     22    }
    1323   
    1424    // set the new measurements
    15     averef = measure_out[Nout].averef;
    16     catID  = measure_out[Nout].catID;
    17     measure_out[Nout] = measure_in[0];
     25    averef = measure_out[m].averef;
     26    catID  = measure_out[m].catID;
     27    measure_out[m] = measure_in[0];
    1828
    1929    // old code: find R,D using average_in[0], the get offset relative to average_out[0].  no longer
    … …  
    2434    // measure_out[Nout].dD = 3600.0*(average_out[0].D - Din);
    2535
    26     measure_out[Nout].dbFlags  = 0;  // XXX why reset these?
    27     measure_out[Nout].averef   = averef;
    28     measure_out[Nout].objID    = average_out[0].objID;
    29     measure_out[Nout].catID    = catID;
     36    measure_out[m].dbFlags  = 0;  // XXX why reset these?
     37    measure_out[m].averef   = averef;
     38    measure_out[m].objID    = average_out[0].objID;
     39    measure_out[m].catID    = catID;
    3040
    31     float dRoff = dvoOffsetR(&measure_out[Nout], average_out);
     41    float dRoff = dvoOffsetR(&measure_out[m], average_out);
    3242
    3343    // rationalize dR
    3444    if (dRoff > +180.0*3600.0) {
    3545      // average on high end of boundary, move star up
    36       measure_out[Nout].R += 360.0;
     46      measure_out[m].R += 360.0;
    3747      dRoff -= 360.0*3600.0;
    3848    }
    3949    if (dRoff < -180.0*3600.0) {
    4050      // average on low end of boundary, move star down
    41       measure_out[Nout].R -= 360.0;
     51      measure_out[m].R -= 360.0;
    4252      dRoff += 360.0*3600.0;
    4353    }
    … …  
    4959      if (fabs(dRoff*cosD) > 10*RADIUS) {
    5060        fprintf (stderr, "surprisingly distant detection: %10.6f,%10.6f vs %10.6f,%10.6f\n",
    51                  average_out[0].R, average_out[0].D, measure_out[Nout].R, measure_out[Nout].D);
     61                 average_out[0].R, average_out[0].D, measure_out[m].R, measure_out[m].D);
    5262      }
    5363    }

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

    r38468 r38986  
    1010}
    1111
    12 int replace_tycho (Average *averageOut, Measure *measureOut, Average *averageInp, Measure *measureInp) {
     12int replace_tycho (Average *averageOut, Measure *measureOut, off_t *next_meas, Average *averageInp, Measure *measureInp) {
    1313
    1414  int i;
    … …  
    1717  int index[6];
    1818
     19  off_t m = averageOut->measureOffset;
     20
    1921  // find all tycho measurements
    2022  for (i = 0; (i < averageOut->Nmeasure) && (Nindex < 6); i++) {
    2123
     24    myAssert (m > -1, "oops");
     25
    2226    int valid = FALSE;
    23     valid = valid || (measureOut[i].photcode == TYCHO_B);
    24     valid = valid || (measureOut[i].photcode == TYCHO_V);
    25     if (!valid) continue;
    26 
    27     index[Nindex] = i;
    28     Nindex ++;
     27    valid = valid || (measureOut[m].photcode == TYCHO_B);
     28    valid = valid || (measureOut[m].photcode == TYCHO_V);
     29    if (valid) {
     30      index[Nindex] = m;
     31      Nindex ++;
     32    }
     33    m = next_meas[m];
    2934  }
    3035

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

    r38851 r38986  
    7272void   ConfigInit                         PROTO((int *argc, char **argv));
    7373       
    74 void   usage_dvopsps                      PROTO(());
     74void   usage_dvopsps                      PROTO((void));
    7575void   initialize_dvopsps                 PROTO((int argc, char **argv));
    7676int    args_dvopsps                       PROTO((int argc, char **argv));
    7777       
    78 void   usage_dvopsps_client               PROTO(());
     78void   usage_dvopsps_client               PROTO((void));
    7979void   initialize_dvopsps_client          PROTO((int argc, char **argv));
    8080int    args_dvopsps_client                PROTO((int argc, char **argv));
    … …  
    8282MYSQL *mysql_dvopsps_connect              PROTO((MYSQL *mysqlBase));
    8383
    84 int    insert_detections_dvopsps          PROTO(());
     84int    insert_detections_dvopsps          PROTO((void));
    8585int    insert_detections_dvopsps_parallel PROTO((SkyTable *sky));
    8686int    insert_detections_dvopsps_catalog  PROTO((Catalog *catalog, MYSQL *mysql));
    … …  
    9494int    assign_detection_values            PROTO((Detections *detection, Measure *measure, Average *average));
    9595
    96 int    init_detections                    PROTO(());
     96int    init_detections                    PROTO((void));
    9797int    append_detections_dvopsps_catalog  PROTO((Catalog *catalog));
    98 int    save_detections_dvopsps            PROTO(());
     98int    save_detections_dvopsps            PROTO((void));
    9999
    100 int    insert_objects_dvopsps             PROTO(());
     100int    insert_objects_dvopsps             PROTO((void));
    101101int    insert_objects_dvopsps_parallel    PROTO((SkyList *sky));
    102102int    insert_objects_dvopsps_catalog     PROTO((Catalog *catalog, char *basename, MYSQL *mysql));
    … …  
    107107int    insert_objects_mysql_init          PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, char *basename));
    108108
    109 int    insert_FWobjects_dvopsps             PROTO(());
     109int    insert_FWobjects_dvopsps             PROTO((void));
    110110int    insert_FWobjects_dvopsps_parallel    PROTO((SkyList *sky));
    111111int    insert_FWobjects_dvopsps_catalog     PROTO((Catalog *catalog, char *basename, MYSQL *mysql));
    … …  
    116116int    insert_FWobjects_mysql_commit        PROTO((IOBuffer *ave_buffer, IOBuffer *sec_buffer, IOBuffer *cpy_buffer, MYSQL *mysql));
    117117
    118 int    insert_FGshape_dvopsps               PROTO(());
     118int    insert_FGshape_dvopsps               PROTO((void));
    119119int    insert_FGshape_dvopsps_parallel      PROTO((SkyList *sky));
    120120int    insert_FGshape_dvopsps_catalog       PROTO((Catalog *catalog, char *basename, MYSQL *mysql));
    … …  
    125125int    insert_FGshape_mysql_commit          PROTO((IOBuffer *ave_buffer, IOBuffer *cpy_buffer, MYSQL *mysql));
    126126
    127 int    insert_skytable                    PROTO(());
     127int    insert_skytable                    PROTO((void));
    128128
    129129int    insert_skytable_mysql_commit       PROTO((IOBuffer *buffer, MYSQL *mysql));
    … …  
    131131int    insert_skytable_mysql_init         PROTO((IOBuffer *buffer));
    132132
    133 int    insert_diffobj_dvopsps             PROTO(());
     133int    insert_diffobj_dvopsps             PROTO((void));
    134134int    insert_diffobj_dvopsps_parallel    PROTO((SkyList *sky));
    135135int    insert_diffobj_dvopsps_catalog     PROTO((Catalog *catalog, char *basename, MYSQL *mysql));

  • trunk/Ohana/src/dvopsps/src/insert_detections_dvopsps_catalog.c

    r38851 r38986  
    109109
    110110  // NOTE for testing, just do a few objects
    111   if (!mysql) {
    112     catalog[0].Naverage = 5;
    113   }
    114111  for (i = 0; i < catalog[0].Naverage; i++) {
    115112
    … …  
    225222    mysql_free_result (result);
    226223  } else {
    227     fprintf (stderr, "%s\n", buffer->buffer);
     224    fprintf (stderr, ".");
    228225  }
    229226

  • trunk/Ohana/src/dvosplit/src/split_averages.c

    r38441 r38986  
    105105        outcatalogs[cat].catflags = DVO_LOAD_AVERAGE | DVO_LOAD_SECFILT;
    106106
     107        SetProtect (TRUE);
    107108        dvo_catalog_save (&outcatalogs[cat], VERBOSE);
     109        SetProtect (FALSE);
    108110        // fprintf (stderr, "secfilt: %d %d %d %d\n", outcatalogs[cat].Nsecfilt_mem, outcatalogs[cat].Nsecfilt_disk, outcatalogs[cat].Nsecfilt_off, outcatalogs[cat].Naverage, outcatalogs[cat].Nsecfilt);
    109111

  • trunk/Ohana/src/dvosplit/src/split_measures.c

    r38441 r38986  
    7373      for (cat = 0; cat < outlist[0].Nregions; cat++) {
    7474        outcatalogs[cat].catflags = DVO_LOAD_MEASURE;
     75
     76        SetProtect (TRUE);
    7577        dvo_catalog_save (&outcatalogs[cat], VERBOSE);
     78        SetProtect (FALSE);
    7679
    7780        outcatalogs[cat].Nmeasure_disk += outcatalogs[cat].Nmeasure;

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

    r38441 r38986  
    103103
    104104float  RADIUS;
     105float  MAX_MAG_2MASS;
    105106
    106107SkyRegion UserPatch;

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

    r37807 r38986  
    104104  if ((N = get_argument (*argc, argv, "-uniform-radec"))) {
    105105    UNIFORM_RADEC = TRUE;
     106    remove_argument (N, argc, argv);
     107  }
     108
     109  MAX_MAG_2MASS = 16.0;
     110  if ((N = get_argument (*argc, argv, "-2mass-limit"))) {
     111    remove_argument (N, argc, argv);
     112    MAX_MAG_2MASS = atof(argv[N]);
    106113    remove_argument (N, argc, argv);
    107114  }

  • trunk/Ohana/src/fakeastro/src/fakestar_catalog.c

    r38471 r38986  
    2121  insert_fakestar (region, stars, Nstars, &catalog);
    2222   
    23   dvo_catalog_save (&catalog, VERBOSE);
    24   dvo_catalog_unlock (&catalog);
     23  SetProtect (TRUE);
     24  if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     25  if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     26  SetProtect (FALSE);
     27
    2528  dvo_catalog_free (&catalog);
    2629

  • trunk/Ohana/src/fakeastro/src/fit_fake_stars.c

    r37807 r38986  
    133133      AstromOffsetTableNewMap(table, order_use, order_use, image);
    134134    }
    135     AstromOffsetMapFit (image[0].coords.offsetMap, Xref, Yref, dX, Nstars, TRUE);
    136     AstromOffsetMapFit (image[0].coords.offsetMap, Xref, Yref, dY, Nstars, FALSE);
     135    AstromOffsetMapFit (image[0].coords.offsetMap, Xref, Yref, dX, NULL, Nstars, TRUE);
     136    AstromOffsetMapFit (image[0].coords.offsetMap, Xref, Yref, dY, NULL, Nstars, FALSE);
    137137
    138138    image[0].coords.Npolyterms = -1;

  • trunk/Ohana/src/fakeastro/src/make_2mass_measures.c

    r37807 r38986  
    2424  // PhotCode *codeK = GetPhotcodebyName ("2MASS_K");
    2525
    26   float ZP = 21.0; // this is chosen to give 16.0 mag stars a flux of 100.0 counts (crude, yes)
    27   float SkyCts = 300.0; // this is chosen to make SN @ 16.0 = 5.0 (
     26  float ZP = MAX_MAG_2MASS + 6.5; // this is chosen to give stars at the limit a flux of 400.0 counts (crude, yes)
     27  float SkyCts = 1000.0; // this is chosen to make SN @ limit ~ 10.0 (
    2828
    2929  int Nmeasure = catalog->Nmeasure;
    … …  
    4545    // make a crude JHK color for now:
    4646    double J_PS1 = secfilt[i*Nsecfilt + Nsec].M - 1.0; // make all stars have y-J = 1.0
    47     if (J_PS1 > 16.0) continue; // only generate 2MASS detections for objects with J_PS1 < 16.0
     47    if (J_PS1 > MAX_MAG_2MASS) continue; // only generate 2MASS detections for objects with J_PS1 < 16.0
    4848
    4949    if (isnan(secfilt[i*Nsecfilt + Nsec].M)) {
    … …  
    5656
    5757      J_PS1 = secfilt[i*Nsecfilt + ns].M; // pretend secfilt.M = J
    58       if (J_PS1 > 16.0) continue; // only generate 2MASS detections for objects with J_PS1 < 16.0
     58      if (J_PS1 > MAX_MAG_2MASS) continue; // only generate 2MASS detections for objects with J_PS1 < 16.0
    5959    }
    6060

  • trunk/Ohana/src/fakeastro/src/save_fake_stars.c

    r38471 r38986  
    2424    catalog.catformat = dvo_catalog_catformat (CATFORMAT);  // set the default catformat from config data
    2525    catalog.catmode   = dvo_catalog_catmode (CATMODE);      // set the default catmode from config data
    26     // catalog.catflags  = DVO_LOAD_AVERAGE | DVO_LOAD_SECFILT | DVO_LOAD_MEASURE | DVO_LOAD_STARPAR; // use this for non-update mode
    27     catalog.catflags  = DVO_LOAD_AVERAGE | DVO_LOAD_SECFILT | DVO_LOAD_STARPAR;
     26    catalog.catflags  = DVO_LOAD_AVERAGE | DVO_LOAD_SECFILT | DVO_LOAD_MEASURE | DVO_LOAD_STARPAR; // use this for non-update mode
     27    // catalog.catflags  = DVO_LOAD_AVERAGE | DVO_LOAD_SECFILT | DVO_LOAD_STARPAR;
    2828    catalog.Nsecfilt  = GetPhotcodeNsecfilt ();
    2929

  • trunk/Ohana/src/getstar/src/MatchImages.c

    • Property svn:mergeinfo deleted
    r38732 r38986  
    2929  tcoords.crval1 = image[0].coords.crval1;
    3030  tcoords.crval2 = image[0].coords.crval2;
     31
    3132  if (!strcmp (&image[0].coords.ctype[4], "-WRP")) {
    3233    myAssert (image[0].coords.mosaic, "should already have tested this");

  • trunk/Ohana/src/getstar/src/write_catalog.c

    r15539 r38986  
    55  /* write out the selected stars */
    66  // XXX need to set the catalog boundaries by hand? RA0-RA1, DEC0-DEC1
    7   dvo_catalog_save   (catalog, VERBOSE);
    8   dvo_catalog_unlock (catalog);
    9   dvo_catalog_free   (catalog);
     7  SetProtect (TRUE);
     8  if (!dvo_catalog_save (catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog->filename); exit (1); }
     9  if (!dvo_catalog_unlock (catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog->filename); exit (1); }
     10  SetProtect (FALSE);
     11  dvo_catalog_free (catalog);
    1012  fprintf (stderr, "SUCCESS\n");
    1113  exit (0);

  • trunk/Ohana/src/kapa2/include/prototypes.h

    r38465 r38986  
    4040void          DrawYErrors         PROTO((KapaGraphWidget *graph, Gobjects *objects));
    4141void          DrawTick            PROTO((Graphic *graphic, Axis *axis, int P, TickMarkData *tick, int naxis));
    42 void          AxisTickScale       PROTO((Axis *axis, double *major, double *minor, int *nsignif));
     42void          AxisTickScale       PROTO((Axis *axis, double *range, double *major, double *minor, int *nsignif));
    4343TickMarkData *CreateAxisTicks     PROTO((Axis *axis, int *nticks));
    4444int           PrintTick           PROTO((char *string, double value, double min, double max, int nsignif));

  • trunk/Ohana/src/kapa2/include/structures.h

    r38465 r38986  
    143143  double fx, dfx, fy, dfy;  /* axis location on graphic */
    144144  double lweight;
     145  double fLabelRange;
     146  double fMinor;
    145147  int color;
    146148} Axis;

  • trunk/Ohana/src/kapa2/src/DrawFrame.c

    r34088 r38986  
    116116
    117117  if ((naxis == 0) || (naxis == 2)) {
    118     x = MAX(x, fx);
    119   }
    120   //   y = MAX(y, fy);
    121   // }
     118    x = MIN(MAX(x, fx),fx+dfx);
     119  }
     120  if ((naxis == 1) || (naxis == 3)) {
     121    y = MAX(MIN(y, fy),fy+dfy);
     122  }
    122123
    123124  dir = ((naxis == 0) || (naxis == 1)) ? -1 : +1;
    … …  
    137138   
    138139    /* temporarily assume rectilinear axes */
    139     if (naxis == 0) { dx = 0; dy = +1.0*pad; pos = 7; }
    140     if (naxis == 2) { dx = 0; dy = -1.0*pad; pos = 1; }
    141 
    142     if (naxis == 1) { dy = 0; dx = -0.5*pad; pos = 3; }
    143     if (naxis == 3) { dy = 0; dx = +0.5*pad; pos = 5; }
     140    if (naxis == 0) { dx = 0; dy = +1.0*pad; pos = 7; } // center, down justified
     141    if (naxis == 2) { dx = 0; dy = -1.0*pad; pos = 1; } // center, up justified
     142
     143    if (naxis == 1) { dy = 0; dx = -0.5*pad; pos = 3; } // left, center justified
     144    if (naxis == 3) { dy = 0; dx = +0.5*pad; pos = 5; } // right, center justified
    144145
    145146    xt = fx + (value-min)*dfx/(max - min) + dx;
    … …  
    154155# define MIN_RANGE 1e-30
    155156
    156 void AxisTickScale (Axis *axis, double *major, double *minor, int *nsignif) {
    157 
    158   double range, lrange, factor, mantis, fmantis, power;
    159 
    160   range = axis[0].max - axis[0].min;
    161   if (fabs(range) < MIN_RANGE) {
    162     range = (range < 0) ? -MIN_RANGE : +MIN_RANGE;
    163   }
    164 
    165   lrange = log10(MAX(fabs(range), MIN_RANGE));
     157void AxisTickScale (Axis *axis, double *range, double *major, double *minor, int *nsignif) {
     158
     159  double lrange, factor, mantis, fmantis, power;
     160
     161  *range = axis->fLabelRange*(axis[0].max - axis[0].min);
     162  if (fabs(*range) < MIN_RANGE) {
     163    *range = (*range < 0) ? -MIN_RANGE : +MIN_RANGE;
     164  }
     165
     166  lrange = log10(MAX(fabs(*range), MIN_RANGE));
     167  double truncRange = ((int) ((lrange + 0.005) * 1000)) / 1000.0;
     168  lrange = truncRange;
     169
    166170  mantis = modf (lrange, &factor);
    167171  if (mantis < 0.0) {
    … …  
    179183  if ((fmantis >= 1.0) && (fmantis <  1.999)) {
    180184    *major = 0.5 * power;
    181     *minor = 0.1 * power;
    182185    *nsignif = factor - 1;
    183186    if (axis[0].areticks == 1) {
    184187      *major = 0.25 * power;
    185       *minor = 0.05 * power;
    186188      *nsignif = factor - 2;
     189    }     
     190    if (axis[0].areticks == 3) {
     191      *major = 1.0 * power;
     192      *nsignif = factor - 1;
    187193    }     
    188194  }
    189195  if ((fmantis >= 1.999) && (fmantis <  3.999)) {
    190196    *major = 1.0 * power;
    191     *minor = 0.2 * power;
    192197    *nsignif = factor;
    193198    if (axis[0].areticks == 1) {
    194199      *major = 0.5 * power;
    195       *minor = 0.1 * power;
    196200      *nsignif = factor - 1;
     201    }     
     202    if (axis[0].areticks == 3) {
     203      *major = 2.0 * power;
     204      *nsignif = factor;
    197205    }     
    198206  }
    199207  if ((fmantis >= 3.999) && (fmantis <  5.999)) {
    200208    *major = 1.0 * power;
    201     *minor = 0.5 * power;
    202209    *nsignif = factor;
    203210    if (axis[0].areticks == 1) {
    204211      *major = 1.0 * power;
    205       *minor = 0.2 * power;
     212      *nsignif = factor;
     213    }     
     214    if (axis[0].areticks == 3) {
     215      *major = 2.0 * power;
    206216      *nsignif = factor;
    207217    }     
    … …  
    209219  if ((fmantis >= 5.999) && (fmantis <   7.999)) {
    210220    *major = 2.0 * power;
    211     *minor = 0.5 * power;
    212221    *nsignif = factor;
    213222    if (axis[0].areticks == 1) {
    214223      *major = 1.0 * power;
    215       *minor = 0.5 * power;
     224      *nsignif = factor;
     225    }     
     226    if (axis[0].areticks == 3) {
     227      *major = 4.0 * power;
    216228      *nsignif = factor;
    217229    }     
    … …  
    219231  if ((fmantis >= 7.999) && (fmantis <  10.000)) {
    220232    *major = 2.5 * power;
    221     *minor = 0.5 * power;
    222       *nsignif = factor - 1;
     233    *nsignif = factor - 1;
    223234    if (axis[0].areticks == 1) {
    224235      *major = 2.0 * power;
    225       *minor = 0.5 * power;
    226       *nsignif = factor;
    227     }     
    228   }
     236      *nsignif = factor;
     237    }     
     238    if (axis[0].areticks == 3) {
     239      *major = 4.0 * power;
     240      *nsignif = factor;
     241    }     
     242  }
     243  *minor = *major / axis->fMinor;
    229244}
    230245
    … …  
    233248  TickMarkData *ticks;
    234249  double range, major, minor, first, value;
    235   int i, NTICKS, done, ifirst, nsignif;
     250  int i, NTICKS, done, nsignif;
    236251
    237252  *nticks = 0;
    … …  
    240255  if (isnan(axis->max) || isinf(axis->max)) return NULL;
    241256 
    242   range = axis->max - axis->min;
    243 
    244   // not sure why I skip out here instead of using the MIN_RANGE value
    245   if (fabs(range) < MIN_RANGE) return NULL;
    246  
    247   if (fabs(range) < MIN_RANGE) {
    248     range = (range < 0) ? -MIN_RANGE : +MIN_RANGE;
    249   }
    250 
    251257  // length of the axis in pixels
    252258  // int nPixels = hypot(axis->dfx, axis->dfy);
    253259  // double dPixels = nPixels / range; // axis pixel-scale
    254260
    255   AxisTickScale (axis, &major, &minor, &nsignif);
     261  AxisTickScale (axis, &range, &major, &minor, &nsignif);
    256262
    257263  // be a little generous
    … …  
    259265  ALLOCATE (ticks, TickMarkData, NTICKS);
    260266
    261   // value of the tick mark
    262   ifirst = (axis->min < 0.0) ? (axis->min/minor - 0.05) : (axis->min/minor + 0.05);
     267  // value of the first tick mark (near axis->min)
     268  double minValue = axis->min / minor;
     269  int ifirst = (int) minValue;
     270
     271  if ((axis->min > 0.0) && (minValue - ifirst > +0.1)) {
     272    ifirst ++;
     273  }
     274  if ((axis->min < 0.0) && (minValue - ifirst < -0.1)) {
     275    ifirst --;
     276  }
    263277  first = minor*ifirst;
    264278 
    265   // allow undershoot by 1 pixel
    266   // double overshoot = (axis->min - first) * dPixels;
    267   // if (overshoot > 0.5) {
    268   //   if (range > 0) {
    269   //     first += minor;
    270   //   } else {
    271   //     first -= minor;
    272   //   }
    273   // }
    274 
    275   // XXX need to fix first and last value for printing label: currently prints first label
    276   // too early & fails to do last label if too close
     279  // only write the labels for the inner fRange of the axies
     280  double minLabelValue = 0.5*(1.0 - 1.001*axis->fLabelRange)*(axis->max - axis->min) + axis->min;
     281  double maxLabelValue = 0.5*(1.0 + 1.001*axis->fLabelRange)*(axis->max - axis->min) + axis->min;
    277282
    278283  // loop to find the ticks
    … …  
    284289    ticks[i].IsMajor |= (fabs((int)((value + 0.5*minor)/major) - (value/major)) < 0.5*(minor/major));
    285290    ticks[i].IsMajor |= (fabs((int)((value - 0.5*minor)/major) - (value/major)) < 0.5*(minor/major));
    286     ticks[i].IsLabel = (ticks[i].IsMajor && axis->islabel);
     291    int inLabelRange = (range > 0) ? (value >= minLabelValue) && (value <= maxLabelValue) : (value <= minLabelValue) && (value >= maxLabelValue);
     292    ticks[i].IsLabel = inLabelRange && ticks[i].IsMajor && axis->islabel;
    287293    ticks[i].value = value;
    288294    ticks[i].nsignif = nsignif;
    … …  
    292298      value -= minor;
    293299   
    294     done |= (range > 0) && (value > axis->max);
    295     done |= (range < 0) && (value < axis->max);
     300    done |= (range > 0) && (value > axis->max + 0.1*minor);
     301    done |= (range < 0) && (value < axis->max - 0.1*minor);
     302    // fprintf (stderr, "%d : %f %f %f %f\n", done, range, value, axis->max, 0.1*minor);
    296303  }
    297304

  • trunk/Ohana/src/kapa2/src/Graphs.c

    r37807 r38986  
    2323    graph[0].axis[i].labelPad = NAN;
    2424    graph[0].axis[i].pad = NAN;
     25    graph[0].axis[i].fLabelRange = 1.0;
     26    graph[0].axis[i].fMinor = 5.0;
    2527  }   
    2628  graph[0].data.ticktextPad = NAN;
    … …  
    3537  graph[0].data.padYm = NAN;
    3638  graph[0].data.padYp = NAN;
     39
     40  graph[0].data.fLabelRangeXm = 1.0;
     41  graph[0].data.fLabelRangeXp = 1.0;
     42  graph[0].data.fLabelRangeYm = 1.0;
     43  graph[0].data.fLabelRangeYp = 1.0;
     44
     45  graph[0].data.fMinorXm = 5.0;
     46  graph[0].data.fMinorXp = 5.0;
     47  graph[0].data.fMinorYm = 5.0;
     48  graph[0].data.fMinorYp = 5.0;
    3749
    3850  for (i = 0; i < 8; i++) {

  • trunk/Ohana/src/kapa2/src/LoadFrame.c

    r29539 r38986  
    3737  graph[0].axis[3].labelPad = graph[0].data.labelPadYp;
    3838
     39  graph[0].axis[0].fLabelRange = graph[0].data.fLabelRangeXm;
     40  graph[0].axis[1].fLabelRange = graph[0].data.fLabelRangeYm;
     41  graph[0].axis[2].fLabelRange = graph[0].data.fLabelRangeXp;
     42  graph[0].axis[3].fLabelRange = graph[0].data.fLabelRangeYp;
     43
     44  graph[0].axis[0].fMinor = graph[0].data.fMinorXm;
     45  graph[0].axis[1].fMinor = graph[0].data.fMinorYm;
     46  graph[0].axis[2].fMinor = graph[0].data.fMinorXp;
     47  graph[0].axis[3].fMinor = graph[0].data.fMinorYp;
     48
    3949  for (i = 0; i < 4; i++) {
    4050    graph[0].axis[i].lweight = graph[0].data.lweight;
    … …  
    6373    case '2':
    6474      graph[0].axis[i].areticks = 2;
     75      break;
     76    case '3':
     77      graph[0].axis[i].areticks = 3;
    6578      break;
    6679    }

  • trunk/Ohana/src/kapa2/src/PSFrame.c

    r34088 r38986  
    8181  y = fy + (value-min)*dfy/(max - min);
    8282
     83  if ((naxis == 0) || (naxis == 2)) {
     84    x = MIN(MAX(x, fx),fx+dfx);
     85  }
     86  if ((naxis == 1) || (naxis == 3)) {
     87    y = MIN(MAX(y, fy),fy+dfy);
     88  }
     89
    8390  dir = ((naxis == 0) || (naxis == 1)) ? +1 : -1;
    8491  dx = dir*size*dfy*n; 

  • trunk/Ohana/src/kapa2/src/SetGraphData.c

    r27790 r38986  
    2727  graph[0].axis[2].labelPad = graph[0].data.labelPadXp;
    2828  graph[0].axis[3].labelPad = graph[0].data.labelPadYp;
     29
     30  graph[0].axis[0].fLabelRange = graph[0].data.fLabelRangeXm;
     31  graph[0].axis[1].fLabelRange = graph[0].data.fLabelRangeYm;
     32  graph[0].axis[2].fLabelRange = graph[0].data.fLabelRangeXp;
     33  graph[0].axis[3].fLabelRange = graph[0].data.fLabelRangeYp;
     34
     35  graph[0].axis[0].fMinor = graph[0].data.fMinorXm;
     36  graph[0].axis[1].fMinor = graph[0].data.fMinorYm;
     37  graph[0].axis[2].fMinor = graph[0].data.fMinorXp;
     38  graph[0].axis[3].fMinor = graph[0].data.fMinorYp;
    2939
    3040  graph[0].axis[0].pad = graph[0].data.padXm;

  • trunk/Ohana/src/kapa2/src/bDrawFrame.c

    r34088 r38986  
    8484  y = fy + (value-min)*dfy/(max - min);
    8585
     86  if ((naxis == 0) || (naxis == 2)) {
     87    x = MIN(MAX(x, fx),fx+dfx);
     88  }
     89  if ((naxis == 1) || (naxis == 3)) {
     90    y = MAX(MIN(y, fy),fy+dfy);
     91  }
     92
    8693  dir = ((naxis == 0) || (naxis == 1)) ? -1 : +1;
    8794  dx = dir*size*dfy*n; 

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

    r38553 r38986  
    5656$(ASRC)/starpar-ps1-sim.$(ARCH).o \
    5757$(ASRC)/galphot.$(ARCH).o \
    58 $(ASRC)/galphot-ps1-v5.$(ARCH).o \
     58$(ASRC)/galphot-ps1-v5-r0.$(ARCH).o \
     59$(ASRC)/galphot-ps1-v5-r1.$(ARCH).o \
    5960$(ASRC)/missing.$(ARCH).o \
    6061$(ASRC)/photcode.$(ARCH).o \
    … …  
    168169$(AINC)/starpar-ps1-sim.h \
    169170$(AINC)/galphot.h \
    170 $(AINC)/galphot-ps1-v5.h \
     171$(AINC)/galphot-ps1-v5-r0.h \
     172$(AINC)/galphot-ps1-v5-r1.h \
    171173$(AINC)/missing.h \
    172174$(AINC)/photcode.h \

  • trunk/Ohana/src/libautocode/def/average-ps1-v5.d

    r38441 r38986  
    2626FIELD ChiSqAve,       CHISQ_POS,   float,           astrometry analysis chisq
    2727FIELD ChiSqPM,        CHISQ_PM,    float,           astrometry analysis chisq
    28 FIELD ChiSqPar,       CHISQ_PAP,   float,           astrometry analysis chisq
     28FIELD ChiSqPar,       CHISQ_PLX,   float,           astrometry analysis chisq
    2929FIELD Tmean,          MEAN_EPOCH,  int,             mean epoch (PM,PAR ref),       unix time seconds
    3030FIELD Trange,         TIME_RANGE,  int,             mean epoch (PM,PAR ref),       unix time seconds
    … …  
    4141FIELD Nlensing,       NLENSING,    unsigned short,  number of lensing measurements
    4242FIELD Nlensobj,       NLENSOBJ,    unsigned short,  number of lensing measurements
    43 FIELD Ngalphot,      NGALPHOT,   unsigned short,  number of galphot measurements
     43FIELD Ngalphot,       NGALPHOT,    unsigned short,  number of galphot measurements
    4444
    4545FIELD measureOffset,  OFF_MEASURE,  int,            offset to first psf measurement
    … …  
    4848FIELD lensobjOffset,  OFF_LENSOBJ,  int,            offset to mean lensing data
    4949FIELD starparOffset,  OFF_STARPAR,  int,            offset to stellar parameter data
    50 FIELD galphotOffset, OFF_GALPHOT, int,              offset to galphot object entry
     50FIELD galphotOffset,  OFF_GALPHOT, int,             offset to galphot object entry
    5151
    5252FIELD refColorBlue,   REF_COLOR_BLUE, float,        color of astrometry ref stars
    … …  
    5757FIELD projectionID,   PROJECTION_ID, short,         ID of projection for primary skycell
    5858
    59 FIELD Nstarpar,       DUMMY,         short,         number of stellar parameter entries
     59FIELD Nstarpar,       N_STAR_PAR,    short,         number of stellar parameter entries
    6060FIELD dummy,          DUMMY,         short,         unassigned bytes
    6161
    … …  
    6969FIELD catID,          CAT_ID,      unsigned int,    unique ID for table in which object was first realized
    7070FIELD extID,          EXT_ID,      uint64_t,        external ID for object (eg PSPS objID)
    71 FIELD extIDgc,        EXT_ID_GC,   uint64_t,        external ID for object in galactic coords
     71
     72# replace extIDgc (unused) with uRgal, uDgal:
     73# FIELD extIDgc,      EXT_ID_GC,   uint64_t,        external ID for object in galactic coords
     74FIELD uRgal,          U_RA_GAL,    float,           modeled proper motion based on galactic motion
     75FIELD uDgal,          U_DEC_GAL,   float,           modeled proper motion based on galactic motion
    7276
    7377# 4 double, 2 uint64_t, 17 float, 12 int, 6 short

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

    r38601 r38986  
    6969FIELD catID,          CAT_ID,      unsigned int,    unique ID for table in which object was first realized
    7070FIELD extID,          EXT_ID,      uint64_t,        external ID for object (eg PSPS objID)
    71 FIELD extIDgc,        EXT_ID_GC,   uint64_t,        external ID for object in galactic coords
     71
     72# replace extIDgc (unused) with uRgal, uDgal:
     73# FIELD extIDgc,      EXT_ID_GC,   uint64_t,        external ID for object in galactic coords
     74FIELD uRgal,          U_RA_GAL,    float,           modeled proper motion based on galactic motion
     75FIELD uDgal,          U_DEC_GAL,   float,           modeled proper motion based on galactic motion
    7276
    7377# this structure should only be used for internal representations

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

    r38062 r38986  
    7070FIELD psfNdof,        PSF_NDOF,      int,            psf degrees of freedom
    7171FIELD psfNpix,        PSF_NPIX,      int,            psf number of pixels
    72 FIELD photFlags2,     PHOT_FLAGS,    int,            flags supplied by photometry program
     72FIELD photFlags2,     PHOT_FLAGS2,   int,            flags supplied by photometry program
    7373FIELD extNsigma,      EXT_NSIGMA,    float,          Nsigma deviation towards EXT
    7474

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

    r38062 r38986  
    4242FIELD XoffCAM,        X_OFF_CAM,     float,          X offset from correction,     pixels
    4343FIELD YoffCAM,        Y_OFF_CAM,     float,          Y offset from correction,     pixels
     44
     45# XXX I can deprecate these as I am going to apply the correct uR,uD offset
     46# XXX not sure how to use this yet...
    4447FIELD RoffGAL,        R_OFF_GAL,     float,          RA offset from correction,    arcsec
    4548FIELD DoffGAL,        D_OFF_GAL,     float,          DEC offset from correction,   arcsec

  • trunk/Ohana/src/libautocode/def/secfilt-ps1-v5.d

    r37246 r38986  
    1010FIELD  Map,           MAG_AP,            float,    ave aperture mag in this band,         mags
    1111FIELD  dMap,          MAG_AP_ERR,        float,    ave aperture mag in this band,         mags
    12 FIELD  sMap,          MAG_AP_STDEV,    float,      standard deviation of ap mags,         mags
     12FIELD  sMap,          MAG_AP_STDEV,      float,      standard deviation of ap mags,         mags
    1313FIELD  Mkron,         MAG_KRON,          float,    ave kron mag in this band,             mags
    1414FIELD  dMkron,        MAG_KRON_ERR,      float,    formal error on average kron mag,      mags
    15 FIELD  sMkron,        MAG_KRON_STDEV,  float,      standard deviation of kron mags,       mags
     15FIELD  sMkron,        MAG_KRON_STDEV,    float,      standard deviation of kron mags,       mags
    1616                                         
    1717# XXX I could add these fields to secfilt or calculate in dvopsps?

  • trunk/Ohana/src/libdvo/Makefile

    r38472 r38986  
    66HOME    =       $(ROOT)/src/libdvo
    77AUTO    =       $(ROOT)/src/libautocode
     8BIN     =       $(HOME)/bin
    89LIB     =       $(HOME)/lib
    910SRC     =       $(HOME)/src
    … …  
    2223FULL_LDFLAGS  = $(BASE_LDFLAGS) -lFITS -lohana
    2324
    24 default: install
     25TEST_CFLAGS   = $(BASE_CFLAGS)
     26TEST_CPPFLAGS = $(BASE_CPPFLAGS)
     27TEST_LDFLAGS  = $(BASE_LDFLAGS) -ldvo -lFITS -lohana -ltap_ohana
     28
     29TESTPROG = tap_AstromOffsetMapIO
     30$(TESTPROG) : % : $(TESTBIN)/%
     31test: $(TESTPROG)
     32        for i in $(TESTPROG); do $(TESTBIN)/$$i 2>&1 | $(TESTHARNESS); done
     33test.verbose: $(TESTPROG)
     34        for i in $(TESTPROG); do $(TESTBIN)/$$i 2>&1 |& $(TESTHARNESS) -v; done
     35
    2536install: $(DESTLIB)/libdvo.a $(DESTLIB)/libdvo.$(DLLTYPE)
    2637libdvo: $(LIB)/libdvo.$(ARCH).a $(LIB)/libdvo.$(ARCH).$(DLLTYPE)
    … …  
    183194        cd $(AUTO) && $(MAKE) clean
    184195
    185 TESTPROG =
    186 $(TESTPROG) : % : $(TESTBIN)/% $(OBJS)
    187 test: $(TESTPROG)
    188         for i in $(TESTPROG); do $(TESTBIN)/$$i 2>&1 | $(TESTHARNESS); done
    189 test.verbose: $(TESTPROG)
    190         for i in $(TESTPROG); do $(TESTBIN)/$$i 2>&1 |& $(TESTHARNESS) -v; done
    191 
    192 .PRECIOUS: $(ASRC)/%.c
     196# .PRECIOUS: $(ASRC)/%.c

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

    r38649 r38986  
    171171  ID_PROPER            = 0x00000010, // star with large proper motion
    172172  ID_TRANSIENT         = 0x00000020, // identified as a non-periodic (stationary) transient
    173   ID_VARIABLE          = 0x00000040, // identified as a period variable
     173  ID_VARIABLE          = 0x00000040, // identified as a periodic variable
    174174  ID_ASTEROID          = 0x00000080, // identified with a known solar-system object (asteroid or other)
    175   // bits 0x00000100 - 0x00008000 are currently unused
     175  ID_STACK_ASTROM      = 0x00000100, // stack position used for astrometry
     176 
     177  // bits 0x00000200 - 0x00008000 are currently unused
    176178  ID_STAR_FIT_AVE      = 0x00010000, // average position fitted
    177179  ID_STAR_FIT_PM       = 0x00020000, // proper motion fitted
    … …  
    813815  int sorted;                           /* is measure table average-sorted? (NOTE this is an int only because gfits_scan %t requires it) */
    814816
    815 
    816817  /* pointers for data manipulation */
    817818  off_t *found_t;
    … …  
    819820
    820821  char *measureRank;
    821 //  off_t *image_t;
    822 //  off_t *mosaic_t;
    823 //  float *X_t;
    824 //  float *Y_t;
    825822  int   *nOwn_t; // relastro uses this to count owned detections per object
    826823
    … …  
    840837int   gfits_db_free                PROTO((FITS_DB *db));
    841838
     839int gfits_fread_uncompressed (Catalog *catalog, FTable *ftable, char *nativeOrder, char VERBOSE);
     840
    842841char *libdvo_version (void);
    843842
    … …  
    903902float PhotZeroPoint (Measure *measure, Average *average, SecFilt *secfilt);
    904903
     904int PhotSecfiltFlags (PhotCode *code, Average *average, SecFilt *secfilt);
     905int PhotNcode (PhotCode *code, Average *average, SecFilt *secfilt);
    905906int   PhotNphot (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
    906907float PhotMstdev (PhotCode *code, Average *average, SecFilt *secfilt, dvoMagClassType class, dvoMagSourceType source);
    … …  
    969970void dvo_catalog_test (Catalog *catalog, int halt);
    970971
    971 int dvo_catalog_backup (Catalog *catalog, int primary);
    972 int dvo_catalog_unlink_backup (Catalog *catalog, int primary);
     972int dvo_catalog_backup (Catalog *catalog, char *suffix, int primary);
     973int dvo_catalog_unlink_backup (Catalog *catalog, char *suffix, int primary);
    973974
    974975/* catmode-specific APIs */

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

    r38638 r38986  
    356356      IMAGE_FWHM_MEDIAN,
    357357      IMAGE_EXPTIME,
     358      IMAGE_EXPNAME_AS_INT,
    358359      IMAGE_NSTAR,
    359360      IMAGE_NCAL,

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

    r31647 r38986  
    1111  double labelPadXm, labelPadYm, labelPadXp, labelPadYp;
    1212  double padXm, padXp, padYm, padYp;
     13  double fLabelRangeXm, fLabelRangeXp, fLabelRangeYm, fLabelRangeYp;
     14  double fMinorXm, fMinorXp, fMinorYm, fMinorYp;
    1315  Coords coords;
    1416  int flipeast, flipnorth;

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

    r38462 r38986  
    5656  float dX;
    5757  float dY;
    58   float **dXv;
    59   float **dYv;
     58  float *dXv;
     59  float *dYv;
    6060  unsigned int tableID;
    6161  unsigned int imageID;
    … …  
    6565typedef struct {
    6666  int Nmap;
     67  int NMAP;
    6768  AstromOffsetMap **map;
    6869   int *imageIDtoTableSeq;
    … …  
    160161
    161162/* in AstromOffsetMapIO.c */
    162 AstromOffsetTable *AstromOffsetMapLoad (char *filename, int VERBOSE);
     163AstromOffsetTable *AstromOffsetMapLoad (char *filename, int Nrows, int VERBOSE);
    163164int AstromOffsetMapSave (AstromOffsetTable *table, char *filename);
    164165AstromOffsetTable *AstromOffsetMapToTable(AstromOffsetMap_Disk_6x6 *map_disk, off_t Nmap);
    165166AstromOffsetMap_Disk_6x6 *AstromOffsetTableToMap(AstromOffsetTable *table, off_t *Nmap);
     167int AstromOffsetTableSetIDs (AstromOffsetTable *table);
     168AstromOffsetTable *AstromOffsetMapAppendToTable(AstromOffsetTable *table, AstromOffsetMap_Disk_6x6 *map_disk, off_t Nmap);
    166169
    167170/* in AstromOffsetMapOps.c */
    168171float AstromOffsetMapValue (AstromOffsetMap *map, float x, float y, int xdir);
    169 int AstromOffsetMapFit (AstromOffsetMap *map, float *x, float *y, float *f, int Npts, int xdir);
     172int AstromOffsetMapFit (AstromOffsetMap *map, float *x, float *y, float *f, float *df, int Npts, int xdir);
    170173
    171174/* in AstromOffsetMapUtils.c */

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

    r38441 r38986  
    2323StarPar_PS1_V5          *StarParInternalTo_PS1_V5 (StarPar *in, off_t Nvalues);
    2424
    25 GalPhot                 *GalPhot_PS1_V5_ToInternal (GalPhot_PS1_V5 *in, off_t Nvalues);
    26 GalPhot_PS1_V5         *GalPhotInternalTo_PS1_V5 (GalPhot *in, off_t Nvalues);
     25GalPhot                 *GalPhot_PS1_V5_R1_ToInternal (GalPhot_PS1_V5_R1 *in, off_t Nvalues);
     26GalPhot                 *GalPhot_PS1_V5_R0_ToInternal (GalPhot_PS1_V5_R0 *in, off_t Nvalues);
     27
     28GalPhot_PS1_V5_R1       *GalPhotInternalTo_PS1_V5_R1 (GalPhot *in, off_t Nvalues);
    2729
    2830PhotCode                *PhotCode_PS1_V5_To_Internal (PhotCode_PS1_V5 *in, off_t Nvalues);

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

    r38441 r38986  
    11# include "dvo.h"
    22
    3 AstromOffsetTable *AstromOffsetMapLoad (char *filename, int VERBOSE) {
     3AstromOffsetTable *AstromOffsetMapLoad (char *filename, int Nrows, int VERBOSE) {
    44
    55  off_t Nmap;
    … …  
    77  Header header;
    88  Matrix matrix;
     9
    910  Header theader;
    1011  FTable ftable;
     12  ftable.header = &theader;
     13  ftable.buffer = NULL;
    1114
    1215  FILE *f = fopen (filename, "r");
    … …  
    1720
    1821  /* load in table data */
    19   ftable.header = &theader;
    2022  if (!gfits_fread_header (f, &header)) {
    2123    if (VERBOSE) fprintf (stderr, "can't read Astrom Offset Map header\n");
    … …  
    3032  }
    3133
    32   // for now, we only have one flavor (6x6)
    33 
    34   if (!gfits_fread_ftable (f, &ftable, "ASTROM_OFFSET_MAP_DISK_6x6")) {
    35     if (VERBOSE) fprintf (stderr, "can't read Astrom Offset Map table\n");
    36     gfits_free_header (&header);
    37     gfits_free_matrix (&matrix);
    38     fclose (f);
    39     return (NULL);
    40   }
    41   AstromOffsetMap_Disk_6x6 *map_disk = gfits_table_get_AstromOffsetMap_Disk_6x6 (&ftable, &Nmap, NULL, NULL);
    42   if (!map_disk) {
    43     fprintf (stderr, "ERROR: failed to read Astrom Offset Map\n");
    44     exit (2);
    45   }
    46 
    47   // AstromOffsetMap_Disk_6x6 *map_disk is an external format stored as an array of maps.
    48   // Convert the disk array of maps to then internal format in a rich structure:
    49   AstromOffsetTable *table = AstromOffsetMapToTable (map_disk, Nmap);
     34  // the output table is not what is stored in the FITS file.  read and convert
     35  // from the disk file format
     36  AstromOffsetTable *table = NULL;
     37
     38  // for now, we only have one flavor (6x6) of disk file format
     39
     40  // loop over the ftable reading blocks of 100k rows at a time
     41  if (Nrows) {
     42    if (!gfits_find_Xheader (f, ftable.header, "ASTROM_OFFSET_MAP_DISK_6x6")) myAbort ("problem 1");
     43    int NrowsTotal = ftable.header[0].Naxis[1];
     44    int Nblocks = (NrowsTotal % Nrows) ? (int) (NrowsTotal / Nrows) + 1 : (NrowsTotal / Nrows);
     45
     46    // allocate the full array up front.  passes through AstromOffsetMapAppendToTable
     47    // check the current allocation and will bump the allocation as needed.
     48    ALLOCATE (table, AstromOffsetTable, 1);
     49    ALLOCATE (table->map, AstromOffsetMap *, NrowsTotal);
     50    table->Nmap = 0;
     51    table->NMAP = NrowsTotal;
     52
     53    // on each call to gfits_fread_ftable_range, we need to reset the FILE pointer to the
     54    // beginning of the data block.  again this seems a little wrong.
     55    off_t diskStart = ftello (f);
     56
     57    int i;
     58    for (i = 0; i < Nblocks; i++) {
     59      if (!gfits_fread_ftable_range (f, FALSE, FALSE, &ftable, i*Nrows, Nrows)) myAbort ("problem 2");
     60   
     61      AstromOffsetMap_Disk_6x6 *map_disk = gfits_table_get_AstromOffsetMap_Disk_6x6 (&ftable, &Nmap, NULL, NULL);
     62      if (!map_disk) myAbort ("ERROR: failed to read Astrom Offset Map\n");
     63
     64      table = AstromOffsetMapAppendToTable (table, map_disk, Nmap);
     65
     66      // XXX this is kind of hack-ish: gfits_fread_ftable_range modifies Naxis[1] to the
     67      // number of rows actually read, but this makes a subsequent read invalid.  I'm
     68      // resetting the value of Naxis[1] before the next read to deal with this problem.
     69      // But is there a more consistent way to address this?
     70
     71      // Answer: the FTable structure could include information about the table
     72      // representation on disk, including start,Nrows values.  I'm not going to mess
     73      // around with that just now.
     74
     75      ftable.header[0].Naxis[1] = NrowsTotal;
     76      fseeko (f, diskStart, SEEK_SET);
     77    }
     78    AstromOffsetTableSetIDs (table);
     79    gfits_free_header (ftable.header);
     80    gfits_free_table  (&ftable);
     81  } else {
     82
     83    // convert the blocks into the equivalent table entries and append
     84    if (!gfits_fread_ftable (f, &ftable, "ASTROM_OFFSET_MAP_DISK_6x6")) {
     85      if (VERBOSE) fprintf (stderr, "can't read Astrom Offset Map table\n");
     86      gfits_free_header (&header);
     87      gfits_free_matrix (&matrix);
     88      fclose (f);
     89      return (NULL);
     90    }
     91    AstromOffsetMap_Disk_6x6 *map_disk = gfits_table_get_AstromOffsetMap_Disk_6x6 (&ftable, &Nmap, NULL, NULL);
     92    if (!map_disk) {
     93      fprintf (stderr, "ERROR: failed to read Astrom Offset Map\n");
     94      exit (2);
     95    }
     96
     97    // AstromOffsetMap_Disk_6x6 *map_disk is an external format stored as an array of maps.
     98    // Convert the disk array of maps to then internal format in a rich structure:
     99    table = AstromOffsetMapToTable (map_disk, Nmap);
     100    gfits_free_table  (&ftable);
     101  }
    50102
    51103  gfits_free_header (&theader);
    52104  gfits_free_matrix (&matrix);
    53   gfits_free_table  (&ftable);
    54105
    55106  return (table);
    … …  
    135186    table->map[i][0].Nx           = map_disk[i].Nx;
    136187    table->map[i][0].Ny           = map_disk[i].Ny;
    137     table->map[i][0].tableID = map_disk[i].tableID;
    138     table->map[i][0].imageID = map_disk[i].imageID;
     188    table->map[i][0].tableID      = map_disk[i].tableID;
     189    table->map[i][0].imageID      = map_disk[i].imageID;
    139190   
    140191    // STORE THESE VALUES?
    141     table->map[i][0].dY           = map_disk[i].dX;
    142     table->map[i][0].dX           = map_disk[i].dY;
     192    table->map[i][0].dX           = map_disk[i].dX;
     193    table->map[i][0].dY           = map_disk[i].dY;
    143194
    144195    // since this was on disk, we obviously keep it
    145196    table->map[i][0].keep         = TRUE;
    146197
    147     ALLOCATE (table->map[i][0].dXv, float *, map_disk[i].Nx);
    148     ALLOCATE (table->map[i][0].dYv, float *, map_disk[i].Nx);
    149 
    150     for (j = 0; j < map_disk[i].Nx; j++) {
    151       ALLOCATE (table->map[i][0].dXv[j], float, map_disk[i].Ny);
    152       ALLOCATE (table->map[i][0].dYv[j], float, map_disk[i].Ny);
    153 
    154       for (k = 0; k < map_disk[i].Ny; k++) {
    155         table->map[i][0].dXv[j][k] = map_disk[i].dXv[j][k];
    156         table->map[i][0].dYv[j][k] = map_disk[i].dYv[j][k];
     198    int Nx = table->map[i][0].Nx;
     199    int Ny = table->map[i][0].Ny;
     200
     201    ALLOCATE (table->map[i][0].dXv, float, Nx*Ny);
     202    ALLOCATE (table->map[i][0].dYv, float, Nx*Ny);
     203
     204    for (j = 0; j < Nx; j++) {
     205      for (k = 0; k < Ny; k++) {
     206        table->map[i][0].dXv[j + k*Nx] = map_disk[i].dXv[j][k];
     207        table->map[i][0].dYv[j + k*Nx] = map_disk[i].dYv[j][k];
    157208      }
    158209    }
    … …  
    182233    map_disk[Ndisk].dY      = table->map[i][0].dY;
    183234
    184    
    185 
    186     for (j = 0; j < map_disk[Ndisk].Nx; j++) {
    187       for (k = 0; k < map_disk[Ndisk].Ny; k++) {
    188         map_disk[Ndisk].dXv[j][k] = table->map[i][0].dXv[j][k];
    189         map_disk[Ndisk].dYv[j][k] = table->map[i][0].dYv[j][k];
     235    int Nx = table->map[i][0].Nx;
     236    int Ny = table->map[i][0].Ny;
     237
     238    for (j = 0; j < Nx; j++) {
     239      for (k = 0; k < Ny; k++) {
     240        map_disk[Ndisk].dXv[j][k] = table->map[i][0].dXv[j + k*Nx];
     241        map_disk[Ndisk].dYv[j][k] = table->map[i][0].dYv[j + k*Nx];
    190242      }
    191243      for (k = map_disk[Ndisk].Ny; k < 6; k++) {
    … …  
    206258}
    207259
     260AstromOffsetTable *AstromOffsetMapAppendToTable(AstromOffsetTable *table, AstromOffsetMap_Disk_6x6 *map_disk, off_t Nmap) {
     261
     262  int i, j, k, Nstart;
     263
     264  if (table == NULL) {
     265    ALLOCATE (table, AstromOffsetTable, 1);
     266    Nstart = 0;
     267    table->Nmap = Nmap;
     268    ALLOCATE (table->map, AstromOffsetMap *, Nmap);
     269  } else {
     270    Nstart = table->Nmap;
     271    if (table->Nmap + Nmap > table->NMAP) {
     272      table->NMAP = table->Nmap + Nmap;
     273      REALLOCATE (table->map, AstromOffsetMap *, table->NMAP);
     274    }
     275    table->Nmap += Nmap;
     276  }
     277
     278  // append map values (this allocates just the area needed for each image, not the
     279  // full 6x6, saving some memory while doing the analysis)
     280  for (i = 0; i < Nmap; i++) {
     281    int N = i + Nstart;
     282    ALLOCATE (table->map[N], AstromOffsetMap, 1);
     283
     284    table->map[N][0].Nx           = map_disk[i].Nx;
     285    table->map[N][0].Ny           = map_disk[i].Ny;
     286    table->map[N][0].tableID      = map_disk[i].tableID;
     287    table->map[N][0].imageID      = map_disk[i].imageID;
     288   
     289    // STORE THESE VALUES?
     290    table->map[N][0].dX           = map_disk[i].dX;
     291    table->map[N][0].dY           = map_disk[i].dY;
     292
     293    // since this was on disk, we obviously keep it
     294    table->map[N][0].keep         = TRUE;
     295
     296    int Nx = table->map[N][0].Nx;
     297    int Ny = table->map[N][0].Ny;
     298
     299    ALLOCATE (table->map[N][0].dXv, float, Nx*Ny);
     300    ALLOCATE (table->map[N][0].dYv, float, Nx*Ny);
     301
     302    for (j = 0; j < Nx; j++) {
     303      for (k = 0; k < Ny; k++) {
     304        table->map[N][0].dXv[j + k*Nx] = map_disk[i].dXv[j][k];
     305        table->map[N][0].dYv[j + k*Nx] = map_disk[i].dYv[j][k];
     306      }
     307    }
     308  }
     309  return table;
     310}
     311
     312int AstromOffsetTableSetIDs (AstromOffsetTable *table) {
     313
     314  int i;
     315
     316  // find the max value of imageID
     317  int MaxTableID = 0;
     318  int MaxImageID = 0;
     319  for (i = 0; i < table->Nmap; i++) {
     320    MaxTableID = MAX(table->map[i][0].tableID, MaxTableID);
     321    MaxImageID = MAX(table->map[i][0].imageID, MaxImageID);
     322  }
     323  table->MaxTableID = MaxTableID;
     324  table->MaxImageID = MaxImageID;
     325
     326  // generate the index and init values to -1
     327  ALLOCATE (table->imageIDtoTableSeq, int, MaxImageID + 1);
     328  for (i = 0; i <= MaxImageID; i++) {
     329    table->imageIDtoTableSeq[i] = -1;
     330  }
     331
     332  // assign the ID values
     333  for (i = 0; i < table->Nmap; i++) {
     334    int ImageID = table->map[i][0].imageID;
     335    myAssert (table->imageIDtoTableSeq[ImageID] == -1, "oops, duplicate image IDs");
     336    table->imageIDtoTableSeq[ImageID] = i;
     337  }
     338  return TRUE;
     339}

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

    r37807 r38986  
    66int dump_map_data (float *x, float *y, float *f, int Npts, char *filename);
    77int AstromOffsetMapFit_Chisq (AstromOffsetMap *map, float *x, float *y, float *f, int Npts, int xdir);
    8 int AstromOffsetMapFit_Median (AstromOffsetMap *map, float *x, float *y, float *f, int Npts, int xdir);
     8int AstromOffsetMapFit_Mean (AstromOffsetMap *map, float *x, float *y, float *f, float *df, int Npts, int xdir);
    99
    1010float AstromOffsetMapValue (AstromOffsetMap *map, float x, float y, int xdir) {
    … …  
    1212  // given x,y find the offset (x-direction) at that location from the map
    1313
    14   float **V = xdir ? map->dXv : map->dYv;
     14  int Nx = map->Nx;
     15  int Ny = map->Ny;
     16
     17  float *V = xdir ? map->dXv : map->dYv;
    1518
    1619  // if there is no spatial information, the value at the point is the value in the map
    17   if ((map->Nx == 1) && (map->Ny == 1)) return V[0][0];
     20  if ((Nx == 1) && (Ny == 1)) return V[0];
    1821
    1922  // if there is no spatial information in 1D, the interpolation is 1D
    20   if (map->Nx == 1) {
     23  if (Nx == 1) {
    2124    float ymo = y * map->dY - 0.5;
    2225    int   ymi = floor(ymo);
    23     ymi = MAX(0,MIN(map->Ny - 2, ymi)); // force range of ymi to be 0,Ny-2 (Ny must be > 1)
     26    ymi = MAX(0,MIN(Ny - 2, ymi)); // force range of ymi to be 0,Ny-2 (Ny must be > 1)
    2427
    2528    float ymf = ymo - ymi;
    2629
    27     float value = ymf * V[0][ymi+1] + (1.0 - ymf) * V[0][ymi];
     30    float value = ymf * V[ymi+1] + (1.0 - ymf) * V[ymi];
    2831    return value;
    2932  }
    3033
    3134  // if there is no spatial information in 1D, the interpolation is 1D
    32   if (map->Ny == 1) {
     35  if (Ny == 1) {
    3336    float xmo = x * map->dX - 0.5;
    3437    int   xmi = floor(xmo);
    35     xmi = MAX(0,MIN(map->Nx - 2, xmi)); // force range of ymi to be 0,Nx-2  (Nx must be > 1)
     38    xmi = MAX(0,MIN(Nx - 2, xmi)); // force range of ymi to be 0,Nx-2  (Nx must be > 1)
    3639
    3740    float xmf = xmo - xmi;
    3841
    39     float value = xmf * V[xmi+1][0] + (1.0 - xmf) * V[xmi][0];
     42    float value = xmf * V[xmi+1] + (1.0 - xmf) * V[xmi];
    4043    return value;
    4144  }
    … …  
    4548  float xmo = x * map->dX - 0.5;
    4649  int   xmi = floor(xmo);
    47   xmi = MAX(0,MIN(map->Nx - 2, xmi)); // force range of ymi to be 0,Nx-1
     50  xmi = MAX(0,MIN(Nx - 2, xmi)); // force range of ymi to be 0,Nx-1
    4851  float xmf = xmo - xmi;
    4952
    5053  float ymo = y * map->dY - 0.5;
    5154  int   ymi = floor(ymo);
    52   ymi = MAX(0,MIN(map->Ny - 2, ymi)); // force range of ymi to be 0,Ny-2
     55  ymi = MAX(0,MIN(Ny - 2, ymi)); // force range of ymi to be 0,Ny-2
    5356  float ymf = ymo - ymi;
    5457
    55   float V00 = V[xmi+0][ymi+0];
    56   float V01 = V[xmi+0][ymi+1];
    57   float V10 = V[xmi+1][ymi+0];
    58   float V11 = V[xmi+1][ymi+1];
     58  float V00 = V[xmi+0 + (ymi+0)*Nx];
     59  float V01 = V[xmi+0 + (ymi+1)*Nx];
     60  float V10 = V[xmi+1 + (ymi+0)*Nx];
     61  float V11 = V[xmi+1 + (ymi+1)*Nx];
    5962
    6063  float Vx0 = V10*xmf + V00*(1.0 - xmf);
    … …  
    6568}
    6669
    67 int AstromOffsetMapFit (AstromOffsetMap *map, float *x, float *y, float *f, int Npts, int xdir) {
    68 
    69   int status = AstromOffsetMapFit_Median (map, x, y, f, Npts, xdir);
     70int AstromOffsetMapFit (AstromOffsetMap *map, float *x, float *y, float *f, float *df, int Npts, int xdir) {
     71
     72  int status = AstromOffsetMapFit_Mean (map, x, y, f, df, Npts, xdir);
    7073  return status;
    7174}
    … …  
    7881
    7982  // choose to map direction:
    80   float **V = xdir ? map->dXv : map->dYv;
     83  float *Vptr = xdir ? map->dXv : map->dYv;
    8184
    8285  // special cases:
    … …  
    8891
    8992    vstats_getstats_f (f, NULL, NULL, Npts, &stats);
    90     V[0][0] = stats.mean;
     93    Vptr[0] = stats.mean;
    9194    return TRUE;
    9295  }
    … …  
    352355    for (iy = 0; iy < Ny; iy++) {
    353356      int I = ix + Nx * iy;
    354       V[ix][iy] = B[I][0];
     357      Vptr[I] = B[I][0];
    355358      // error[ix][iy] = sqrt(A[I][I]);
    356359    }
    … …  
    371374// given (x,y),value vector sets, choose the map that minimizes the difference between
    372375// the values and bilinear interpolation of the map
    373 int AstromOffsetMapFit_Median (AstromOffsetMap *map, float *x, float *y, float *f, int Npts, int xdir) {
     376int AstromOffsetMapFit_Mean (AstromOffsetMap *map, float *x, float *y, float *f, float *df, int Npts, int xdir) {
    374377
    375378  int i, ix, iy;
    376379
    377380  // choose to map direction:
    378   float **V = xdir ? map->dXv : map->dYv;
     381  float *Vptr = xdir ? map->dXv : map->dYv;
    379382
    380383  // measure clipped median in each bin
    … …  
    386389  int Npix = Nx*Ny;
    387390
    388   double **values;
     391  double **values, **dvalues;
    389392  int    *Nvalue;
    390393  ALLOCATE (Nvalue, int, Npix);
    391394  ALLOCATE (values, double *, Npix);
     395  ALLOCATE (dvalues, double *, Npix);
    392396  for (i = 0; i < Npix; i++) {
    393397    ALLOCATE (values[i], double, Npts);
     398    ALLOCATE (dvalues[i], double, Npts);
    394399    Nvalue[i] = 0;
    395400  }
    … …  
    400405    // data value & weight for this point
    401406    if (!isfinite(f[i])) continue;
     407    if (df && !isfinite(df[i])) continue;
     408    if (df && df[i] == 0.0) continue;
    402409
    403410    // if (mask && (mask[i] & maskValue)) continue;
    … …  
    414421    int N = Nvalue[I];
    415422    values[I][N] = f[i];
     423    dvalues[I][N] = df ? df[i] : 1.0;
    416424    Nvalue[I] ++;
    417425  }   
    … …  
    421429      int I = ix + Nx * iy;
    422430      if (Nvalue[I] > 5) {
    423         vstats_getstats (values[I], NULL, NULL, Nvalue[I], &stats);
    424         V[ix][iy] = stats.mean;
     431        vstats_getstats (values[I], dvalues[I], NULL, Nvalue[I], &stats);
     432        Vptr[I] = stats.mean;
    425433      } else {
    426         V[ix][iy] = NAN;
     434        Vptr[I] = NAN;
    427435      }
    428436    }
    … …  
    432440  for (i = 0; i < Npix; i++) {
    433441    free (values[i]);
     442    free (dvalues[i]);
    434443  }   
    435444  free (values);
     445  free (dvalues);
    436446  free (Nvalue);
    437447
    … …  
    453463  int ix, iy;
    454464
    455   float **Vfix = NULL;
    456   ALLOCATE (Vfix, float *, Nx);
     465  float *Vfix = NULL;
     466  ALLOCATE (Vfix, float, Nx*Ny);
    457467  for (ix = 0; ix < Nx; ix++) {
    458     ALLOCATE (Vfix[ix], float, Ny);
    459     for (iy = 0; iy < Ny; iy++) {
    460       Vfix[ix][iy] = NAN;
     468    for (iy = 0; iy < Ny; iy++) {
     469      Vfix[ix + iy*Nx] = NAN;
    461470    }
    462471  }
    … …  
    468477  for (ix = 0; ix < Nx; ix++) {
    469478    for (iy = 0; iy < Ny; iy++) {
    470       float value = xdir ? map->dXv[ix][iy] : map->dYv[ix][iy];
     479      int I = ix + iy*Nx;
     480      float value = xdir ? map->dXv[I] : map->dYv[I];
    471481      if (isnan(value)) continue;
    472482      mean += value;
    … …  
    479489  for (ix = 0; ix < Nx; ix++) {
    480490    for (iy = 0; iy < Ny; iy++) {
    481 
    482       float value = xdir ? map->dXv[ix][iy] : map->dYv[ix][iy];
     491      int I = ix + iy*Nx;
     492      float value = xdir ? map->dXv[I] : map->dYv[I];
    483493      if (!isnan(value)) {
    484         Vfix[ix][iy] = value;
     494        Vfix[I] = value;
    485495        continue;
    486496      }
    … …  
    499509          if (ny < 0) continue;
    500510          if (ny >= Ny) continue;
    501           float value = xdir ? map->dXv[nx][ny] : map->dYv[nx][ny];
     511          int I = ix + iy*Nx;
     512          float value = xdir ? map->dXv[I] : map->dYv[I];
    502513          if (isnan(value)) continue;
    503514
    … …  
    508519      // if there are no valid (non-NAN) local pixels, use global mean
    509520      meanLocal = (npixLocal > 0.0) ? meanLocal / npixLocal : mean;
    510       Vfix[ix][iy] = meanLocal;
     521      Vfix[I] = meanLocal;
    511522    }
    512523  }
    … …  
    515526  for (ix = 0; ix < Ny; ix++) {
    516527    for (iy = 0; iy < Ny; iy++) {
     528      int I = ix + iy*Nx;
    517529      if (xdir) {
    518         map->dXv[ix][iy] = Vfix[ix][iy];
     530        map->dXv[I] = Vfix[I];
    519531      } else {
    520         map->dYv[ix][iy] = Vfix[ix][iy];
    521       }
    522     }
    523   }
    524   for (ix = 0; ix < Nx; ix++) {
    525     free (Vfix[ix]);
     532        map->dYv[I] = Vfix[I];
     533      }
     534    }
    526535  }
    527536  free (Vfix);

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

    r37807 r38986  
    3636  map->keep = TRUE; // output map size
    3737
    38   ALLOCATE (map->dXv, float *, map->Nx);
    39   ALLOCATE (map->dYv, float *, map->Nx);
    40 
    41   int j, k;
    42   for (j = 0; j < map->Nx; j++) {
    43     ALLOCATE (map->dXv[j], float, map->Ny);
    44     ALLOCATE (map->dYv[j], float, map->Ny);
    45 
    46     for (k = 0; k < map->Ny; k++) {
    47       map->dXv[j][k] = 0.0;
    48       map->dYv[j][k] = 0.0;
     38  ALLOCATE (map->dXv, float, Nx*Ny);
     39  ALLOCATE (map->dYv, float, Nx*Ny);
     40
     41  int j, k;
     42  for (j = 0; j < Nx; j++) {
     43    for (k = 0; k < Ny; k++) {
     44      map->dXv[j + k*Nx] = 0.0;
     45      map->dYv[j + k*Nx] = 0.0;
    4946    }
    5047  }
    … …  
    5653
    5754  if (!map) return;
    58 
    59   int j;
    60   for (j = 0; j < map->Nx; j++) {
    61     if (map->dXv) free (map->dXv[j]);
    62     if (map->dYv) free (map->dYv[j]);
    63   }
    6455
    6556  free (map->dXv);
    … …  
    7667
    7768  // rather than try to figure out how to resize, and free/allocate, lets just free the old arrays and make new ones
    78   for (j = 0; j < map->Nx; j++) {
    79     if (map->dXv) free (map->dXv[j]);
    80     if (map->dYv) free (map->dYv[j]);
    81   }
    8269  free (map->dXv);
    8370  free (map->dYv);
    … …  
    9077  map->keep = TRUE; // output map size
    9178
    92   ALLOCATE (map->dXv, float *, map->Nx);
    93   ALLOCATE (map->dYv, float *, map->Nx);
    94 
    95   for (j = 0; j < map->Nx; j++) {
    96     ALLOCATE (map->dXv[j], float, map->Ny);
    97     ALLOCATE (map->dYv[j], float, map->Ny);
    98 
    99     for (k = 0; k < map->Ny; k++) {
    100       map->dXv[j][k] = 0.0;
    101       map->dYv[j][k] = 0.0;
     79  ALLOCATE (map->dXv, float, Nx*Ny);
     80  ALLOCATE (map->dYv, float, Nx*Ny);
     81
     82  for (j = 0; j < Nx; j++) {
     83    for (k = 0; k < Ny; k++) {
     84      map->dXv[j + k*Nx] = 0.0;
     85      map->dYv[j + k*Nx] = 0.0;
    10286    }
    10387  }
    … …  
    116100  tgt->tableID = map->tableID;
    117101
    118   int j, k;
    119   for (j = 0; j < tgt->Nx; j++) {
    120     for (k = 0; k < map->Ny; k++) {
    121       tgt->dXv[j][k] = map->dXv[j][k];
    122       tgt->dYv[j][k] = map->dYv[j][k];
     102  int Nx = map->Nx;
     103  int Ny = map->Ny;
     104
     105  int j, k;
     106  for (j = 0; j < Nx; j++) {
     107    for (k = 0; k < Ny; k++) {
     108      tgt->dXv[j + k*Nx] = map->dXv[j + k*Nx];
     109      tgt->dYv[j + k*Nx] = map->dYv[j + k*Nx];
    123110    }
    124111  }
    … …  
    139126  tgt->keep = src->keep;
    140127
    141   int j, k;
    142   for (j = 0; j < tgt->Nx; j++) {
    143     for (k = 0; k < src->Ny; k++) {
    144       tgt->dXv[j][k] = src->dXv[j][k];
    145       tgt->dYv[j][k] = src->dYv[j][k];
     128  int Nx = src->dX;
     129  int Ny = src->dY;
     130
     131  int j, k;
     132  for (j = 0; j < Nx; j++) {
     133    for (k = 0; k < Ny; k++) {
     134      tgt->dXv[j + k*Nx] = src->dXv[j + k*Nx];
     135      tgt->dYv[j + k*Nx] = src->dYv[j + k*Nx];
    146136    }
    147137  }
    … …  
    153143  if (!table) return;
    154144
    155   int i, j;
     145  int i;
    156146  for (i = 0; i < table->Nmap; i++) {
    157     for (j = 0; j < table->map[i][0].Nx; j++) {
    158       free (table->map[i][0].dXv[j]);
    159       free (table->map[i][0].dYv[j]);
    160     }
    161147    if (!table->map[i]) continue;
    162148    FREE (table->map[i][0].dXv);
    … …  
    260246  }
    261247
     248  int Nx = map->Nx;
     249  int Ny = map->Ny;
     250
    262251  fprintf (f, "imageID: %d, tableID: %d (dX: %f, dY: %f), keep: %d\n", map->imageID, map->tableID, map->dX, map->dY, map->keep);
    263252  int ix, iy;
    264253  fprintf (f, "dXv map:\n");
    265   for (ix = 0; ix < map->Nx; ix++) {
    266     for (iy = 0; iy < map->Ny; iy++) {
    267       fprintf (f, "%9.5f ", map->dXv[ix][iy]);
     254  for (ix = 0; ix < Nx; ix++) {
     255    for (iy = 0; iy < Ny; iy++) {
     256      fprintf (f, "%9.5f ", map->dXv[ix + iy*Nx]);
    268257    }
    269258    fprintf (f, "\n");
    270259  }
    271260  fprintf (f, "dYv map:\n");
    272   for (ix = 0; ix < map->Nx; ix++) {
    273     for (iy = 0; iy < map->Ny; iy++) {
    274       fprintf (f, "%9.5f ", map->dYv[ix][iy]);
     261  for (ix = 0; ix < Nx; ix++) {
     262    for (iy = 0; iy < Ny; iy++) {
     263      fprintf (f, "%9.5f ", map->dYv[ix + iy*Nx]);
    275264    }
    276265    fprintf (f, "\n");

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

    r38553 r38986  
    8585
    8686  if (table) AstromOffsetTableFree(table);
    87   table = AstromOffsetMapLoad (mapfile, FALSE);
     87  table = AstromOffsetMapLoad (mapfile, 100000, FALSE);
    8888
    8989  // assign images.coords.offsetMap -> table->map[i]

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

    r37807 r38986  
    233233      value.Flt = image[N].exptime;
    234234      break;
     235
     236    case IMAGE_EXPNAME_AS_INT:
     237      // XXX NOTE this does not handle gpc2 images
     238      if ((image[N].name[0] == 'o') && (image[N].name[5] == 'g') && (image[N].name[10] == 'o')) {
     239        int mjd  = atoi(&image[N].name[1]);
     240        int Nexp = atoi(&image[N].name[6]);
     241        value.Int = mjd * 10000 + Nexp;
     242      }
     243      break;
     244
    235245    case IMAGE_SIDTIME:
    236246      value.Flt = image[N].sidtime;

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

    r38635 r38986  
    241241          break;
    242242
    243         case MAG_OPTION_STDEV:
    244         case MAG_OPTION_CHISQ:
    245         case MAG_OPTION_MIN:
    246         case MAG_OPTION_MAX:
    247         case MAG_OPTION_NCODE:
    248         case MAG_OPTION_NPHOT:
    249         case MAG_OPTION_UC_DIST:
    250         case MAG_OPTION_FLAGS:
     243          // the following are all values which are come from the secfit table
     244        case MAG_OPTION_STDEV:   { value.Flt = PhotMstdev (equiv, average, secfilt, field->magClass, field->magSource); break; }
     245        case MAG_OPTION_CHISQ:   { value.Flt = PhotXm (equiv, average, secfilt); break; }
     246        case MAG_OPTION_MIN:     { value.Flt = PhotMmin (equiv, average, secfilt); break;}
     247        case MAG_OPTION_MAX:     { value.Flt = PhotMmax (equiv, average, secfilt); break;}
     248        case MAG_OPTION_NCODE:   { value.Int = PhotNcode (equiv, average, secfilt); break; }
     249        case MAG_OPTION_NPHOT:   { value.Int = PhotNphot (equiv, average, secfilt, field->magClass, field->magSource); break; }
     250        case MAG_OPTION_UC_DIST: { value.Flt = PhotUCdist (equiv, average, secfilt); break; }
     251        case MAG_OPTION_FLAGS:   { value.Int = PhotSecfiltFlags (equiv, average, secfilt); break; }
     252         
     253          // the following values come from the mean lensobj table
    251254        case MAG_OPTION_X11_SM_OBJ:
    252255        case MAG_OPTION_X12_SM_OBJ:

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

    r38638 r38986  
    356356    dvoMagSourceType source = GetMagSource (word);
    357357    if (source != MAG_SRC_NONE) {
     358      // if mySource is already set, then we have two 'source' elements (an error)
    358359      if (mySource != MAG_SRC_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; }
    359360      mySource = source;
    … …  
    364365    dvoMagLevelType level = GetMagLevel (word);
    365366    if (level != MAG_LEVEL_NONE) {
     367      // if myLevel is already set, then we have two 'level' elements (an error)
    366368      if (myLevel != MAG_LEVEL_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; }
    367369      myLevel = level;
    … …  
    372374    dvoMagClassType class = GetMagClass (word);
    373375    if (class != MAG_CLASS_NONE) {
     376      // if myClass is already set, then we have two 'class' elements (an error)
    374377      if (myClass != MAG_CLASS_NONE) { fprintf (stderr, "invalid selection %s in %s\n", word, fieldName); free (word); return FALSE; }
    375378      myClass = class;
    … …  
    380383    dvoMagOptionType option = GetMagOption (word);
    381384    if (option != MAG_OPTION_NONE) {
    382       // some combinations are OK: mag + err -> err
    383       if ((myOption == MAG_OPTION_MAG) && (option == MAG_OPTION_ERR)) {
     385      // if myClass is already set, then we have two 'class' elements
     386      // this is an error unless the request was of the form mag:value
     387      // if so, then code->type will be PHOT_MAG
     388
     389      if (code->type == PHOT_MAG) {
     390        // mag:err -> magerr
     391        if ((myOption == MAG_OPTION_MAG) && (option == MAG_OPTION_ERR)) {
     392          myOption = MAG_OPTION_ERR;
     393          ptr = skipword (ptr);
     394          continue;
     395        }
     396        // flux:err -> fluxerr
     397        if ((myOption == MAG_OPTION_FLUX) && (option == MAG_OPTION_ERR)) {
     398          myOption = MAG_OPTION_FLUX_ERR;
     399          ptr = skipword (ptr);
     400          continue;
     401        }
    384402        myOption = option;
    385         ptr = skipword (ptr);
    386         continue;
    387       }
    388       // some combinations are OK: err + mag -> err
    389       if ((myOption == MAG_OPTION_ERR) && (option == MAG_OPTION_MAG)) {
    390         ptr = skipword (ptr);
    391         continue;
    392       }
    393       // some combinations are OK: flux + err -> FLUX_ERR
    394       if ((myOption == MAG_OPTION_FLUX) && (option == MAG_OPTION_ERR)) {
    395         myOption = MAG_OPTION_FLUX_ERR;
    396         ptr = skipword (ptr);
    397         continue;
    398       }
    399       // some combinations are OK: err + flux -> FLUX_ERR
    400       if ((myOption == MAG_OPTION_ERR) && (option == MAG_OPTION_FLUX)) {
    401         myOption = MAG_OPTION_FLUX_ERR;
    402         ptr = skipword (ptr);
    403         continue;
    404       }
    405       // some combinations are OK: flux + fluxerr -> FLUX_ERR
    406       if ((myOption == MAG_OPTION_FLUX) && (option == MAG_OPTION_FLUX_ERR)) {
    407         myOption = MAG_OPTION_FLUX_ERR;
    408         ptr = skipword (ptr);
    409         continue;
    410       }
    411       // some combinations are OK: fluxerr + flux -> FLUX_ERR
    412       if ((myOption == MAG_OPTION_FLUX_ERR) && (option == MAG_OPTION_FLUX)) {
    413         myOption = MAG_OPTION_FLUX_ERR;
    414403        ptr = skipword (ptr);
    415404        continue;
    … …  
    815804  if (!strcasecmp (fieldName, "photcode" )) ESCAPE (IMAGE_PHOTCODE,  OPIHI_INT);
    816805  if (!strcasecmp (fieldName, "exptime"  )) ESCAPE (IMAGE_EXPTIME,   OPIHI_FLT);
     806  if (!strcasecmp (fieldName, "expname"  )) ESCAPE (IMAGE_EXPNAME_AS_INT, OPIHI_INT);
    817807  if (!strcasecmp (fieldName, "sidtime"  )) ESCAPE (IMAGE_SIDTIME,   OPIHI_FLT);
    818808

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

    r38553 r38986  
    200200  average->catID           = 0;
    201201  average->extID           = 0;
    202   average->extIDgc         = 0;
     202
     203  average->uRgal           = NAN;
     204  average->uDgal           = NAN;
    203205}
    204206
    … …  
    600602
    601603  /* pointers for data manipulation */
    602   // catalog[0].X_t = NULL;
    603   // catalog[0].Y_t = NULL;
    604604  catalog[0].nOwn_t = NULL;
    605605  catalog[0].found_t = NULL;
    606   // catalog[0].image_t = NULL;
    607   // catalog[0].mosaic_t = NULL;
    608606  catalog[0].foundWarp_t = NULL;
     607  catalog[0].measureRank = NULL;
    609608}
    610609
    … …  
    922921void dvo_catalog_free (Catalog *catalog) {
    923922
     923  if (!catalog) return;
     924
    924925  if (catalog[0].catmode == DVO_MODE_SPLIT) {
    925926
    … …  
    10441045
    10451046// make a backup of this catalog (including the measure, secfilt, and missing tables as needed)
    1046 int dvo_catalog_backup (Catalog *catalog, int primary) {
     1047int dvo_catalog_backup (Catalog *catalog, char *suffix, int primary) {
    10471048
    10481049  // skip empty cpt files
    … …  
    10521053
    10531054  char tmpfilename[DVO_MAX_PATH];
    1054   int status = snprintf (tmpfilename, DVO_MAX_PATH, "%s~", catalog->filename);
     1055  int status = snprintf (tmpfilename, DVO_MAX_PATH, "%s%s", catalog->filename, suffix);
    10551056  if (status >= DVO_MAX_PATH) {
    10561057    fprintf (stderr, "path name too long: %s\n", catalog->filename);
    … …  
    10671068  }
    10681069
     1070  // play it safe: do not overwrite an existing backup file
     1071  struct stat fileStats;
     1072  status = stat (tmpfilename, &fileStats);
     1073  if (!status) {
     1074    fprintf (stderr, "ERROR: backup file %s already exists, exiting\n", tmpfilename);
     1075    return FALSE;
     1076  }
     1077 
     1078  // some error accessing the file.  there is only one acceptable error: file not found
     1079  if (status && (errno != ENOENT)) {
     1080    perror ("problem with output target");
     1081    return FALSE;
     1082  }
     1083
    10691084  status = rename (catalog->filename, tmpfilename);
    10701085  if (status) {
    … …  
    10851100  if (catalog[0].catmode == DVO_MODE_SPLIT) {
    10861101    if (catalog[0].measure_catalog != NULL) {
    1087       if (!dvo_catalog_backup (catalog[0].measure_catalog, FALSE)) {
     1102      if (!dvo_catalog_backup (catalog[0].measure_catalog, suffix, FALSE)) {
    10881103        return FALSE;
    10891104      }
    10901105    }
    10911106    if (catalog[0].missing_catalog != NULL) {
    1092       if (!dvo_catalog_backup (catalog[0].missing_catalog, FALSE)) {
     1107      if (!dvo_catalog_backup (catalog[0].missing_catalog, suffix, FALSE)) {
    10931108        return FALSE;
    10941109      }
    10951110    }
    10961111    if (catalog[0].secfilt_catalog != NULL) {
    1097       if (!dvo_catalog_backup (catalog[0].secfilt_catalog, FALSE)) {
     1112      if (!dvo_catalog_backup (catalog[0].secfilt_catalog, suffix, FALSE)) {
    10981113        return FALSE;
    10991114      }
    … …  
    11041119        status = dvo_catalog_lock (catalog[0].lensing_catalog, lockmode);
    11051120      } else {
    1106         if (!dvo_catalog_backup (catalog[0].lensing_catalog, FALSE)) {
     1121        if (!dvo_catalog_backup (catalog[0].lensing_catalog, suffix, FALSE)) {
    11071122          return FALSE;
    11081123        }
    … …  
    11141129        status = dvo_catalog_lock (catalog[0].lensobj_catalog, lockmode);
    11151130      } else {
    1116         if (!dvo_catalog_backup (catalog[0].lensobj_catalog, FALSE)) {
     1131        if (!dvo_catalog_backup (catalog[0].lensobj_catalog, suffix, FALSE)) {
    11171132          return FALSE;
    11181133        }
    … …  
    11241139        status = dvo_catalog_lock (catalog[0].starpar_catalog, lockmode);
    11251140      } else {
    1126         if (!dvo_catalog_backup (catalog[0].starpar_catalog, FALSE)) {
     1141        if (!dvo_catalog_backup (catalog[0].starpar_catalog, suffix, FALSE)) {
    11271142          return FALSE;
    11281143        }
    … …  
    11341149        status = dvo_catalog_lock (catalog[0].galphot_catalog, lockmode);
    11351150      } else {
    1136         if (!dvo_catalog_backup (catalog[0].galphot_catalog, FALSE)) {
     1151        if (!dvo_catalog_backup (catalog[0].galphot_catalog, suffix, FALSE)) {
    11371152          return FALSE;
    11381153        }
    … …  
    11441159
    11451160// make a backup of this catalog (including the measure, secfilt, and missing tables as needed)
    1146 int dvo_catalog_unlink_backup (Catalog *catalog, int primary) {
     1161int dvo_catalog_unlink_backup (Catalog *catalog, char *suffix, int primary) {
    11471162
    11481163  if (primary && !catalog->Naverage_disk) {
    … …  
    11521167
    11531168  char tmpfilename[DVO_MAX_PATH];
    1154   int status = snprintf (tmpfilename, DVO_MAX_PATH, "%s~", catalog->filename);
     1169  int status = snprintf (tmpfilename, DVO_MAX_PATH, "%s%s", catalog->filename, suffix);
    11551170  if (status >= DVO_MAX_PATH) {
    11561171    fprintf (stderr, "path name too long: %s\n", catalog->filename);
    … …  
    11681183  if (catalog[0].catmode == DVO_MODE_SPLIT) {
    11691184    if (catalog[0].measure_catalog != NULL) {
    1170       if (!dvo_catalog_unlink_backup (catalog[0].measure_catalog, FALSE)) {
     1185      if (!dvo_catalog_unlink_backup (catalog[0].measure_catalog, suffix, FALSE)) {
    11711186        outStatus = FALSE;
    11721187      }
    11731188    }
    11741189    if (catalog[0].missing_catalog != NULL) {
    1175       if (!dvo_catalog_unlink_backup (catalog[0].missing_catalog, FALSE)) {
     1190      if (!dvo_catalog_unlink_backup (catalog[0].missing_catalog, suffix, FALSE)) {
    11761191        outStatus = FALSE;
    11771192      }
    11781193    }
    11791194    if (catalog[0].secfilt_catalog != NULL) {
    1180       if (!dvo_catalog_unlink_backup (catalog[0].secfilt_catalog, FALSE)) {
     1195      if (!dvo_catalog_unlink_backup (catalog[0].secfilt_catalog, suffix, FALSE)) {
    11811196        outStatus = FALSE;
    11821197      }
    11831198    }
    11841199    if ((catalog[0].lensing_catalog != NULL) && (catalog[0].Nlensing_disk > 0)) {
    1185       if (!dvo_catalog_unlink_backup (catalog[0].lensing_catalog, FALSE)) {
     1200      if (!dvo_catalog_unlink_backup (catalog[0].lensing_catalog, suffix, FALSE)) {
    11861201        outStatus = FALSE;
    11871202      }
    11881203    }
    11891204    if ((catalog[0].lensobj_catalog != NULL) && (catalog[0].Nlensobj_disk > 0)) {
    1190       if (!dvo_catalog_unlink_backup (catalog[0].lensobj_catalog, FALSE)) {
     1205      if (!dvo_catalog_unlink_backup (catalog[0].lensobj_catalog, suffix, FALSE)) {
    11911206        outStatus = FALSE;
    11921207      }
    11931208    }
    11941209    if ((catalog[0].starpar_catalog != NULL) && (catalog[0].Nstarpar_disk > 0)) {
    1195       if (!dvo_catalog_unlink_backup (catalog[0].starpar_catalog, FALSE)) {
     1210      if (!dvo_catalog_unlink_backup (catalog[0].starpar_catalog, suffix, FALSE)) {
    11961211        outStatus = FALSE;
    11971212      }
    11981213    }
    11991214    if ((catalog[0].galphot_catalog != NULL) && (catalog[0].Ngalphot_disk > 0)) {
    1200       if (!dvo_catalog_unlink_backup (catalog[0].galphot_catalog, FALSE)) {
     1215      if (!dvo_catalog_unlink_backup (catalog[0].galphot_catalog, suffix, FALSE)) {
    12011216        outStatus = FALSE;
    12021217      }

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

    r38553 r38986  
    9292  if (OHANA_MEMCHECK) ohana_memcheck (TRUE);
    9393 
     94  if (!catalog->f) return TRUE;
     95
    9496  /* rewind file pointers and truncate (file is still open) */
    9597  if (fseeko (catalog->f, 0LL, SEEK_SET)) {
    … …  
    98100    return FALSE;
    99101  }
     102
     103  if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    100104
    101105  // write PHU header
    … …  
    118122  gfits_free_matrix (&matrix);
    119123# endif
     124
     125  if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    120126
    121127  FTable *outtable = ftable;
    … …  
    135141    char *compressMode = dvo_catalog_compress_string (catalog->catcompress);
    136142    // I should test how Ntile affects fpack/funpack and speed
    137     if (!gfits_compress_table (ftable, &cmptable, 1000, compressMode)) {
     143    if (!gfits_compress_table (ftable, &cmptable, 10000, compressMode)) {
    138144      fprintf (stderr, "compression failure\n");
    139145      free (compressMode);
    … …  
    548554    }
    549555    /* read Average table data : format is irrelevant here */
    550     if (!gfits_fread_ftable_range (catalog[0].f, FALSE, &ftable, start, Nrows)) {
     556    if (!gfits_fread_ftable_range (catalog[0].f, FALSE, FALSE, &ftable, start, Nrows)) {
    551557      if (VERBOSE) fprintf (stderr, "can't read table average data");
    552558      return (FALSE);
    … …  
    578584    }
    579585    /* read Secfilt table data : format is irrelevant here */
    580     if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start*catalog[0].Nsecfilt, catalog[0].Naverage*catalog[0].Nsecfilt)) {
     586    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, FALSE, &ftable, start*catalog[0].Nsecfilt, catalog[0].Naverage*catalog[0].Nsecfilt)) {
    581587      if (VERBOSE) fprintf (stderr, "can't read table measure data");
    582588      return (FALSE);
    … …  
    614620    }
    615621    /* read Measure table data : format is irrelevant here */
    616     if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
     622    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, FALSE, &ftable, start, Nrows)) {
    617623      if (VERBOSE) fprintf (stderr, "can't read table measure data");
    618624      return (FALSE);
    … …  
    645651    }
    646652    /* read Missing table data : format is irrelevant here */
    647     if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
     653    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, FALSE, &ftable, start, Nrows)) {
    648654      if (VERBOSE) fprintf (stderr, "can't read table missing data");
    649655      return (FALSE);
    … …  
    679685    }
    680686    /* read Lensing table data : format is irrelevant here */
    681     if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
     687    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, FALSE, &ftable, start, Nrows)) {
    682688      if (VERBOSE) fprintf (stderr, "can't read table lensing data");
    683689      return (FALSE);
    … …  
    710716    }
    711717    /* read Lensobj table data : format is irrelevant here */
    712     if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
     718    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, FALSE, &ftable, start, Nrows)) {
    713719      if (VERBOSE) fprintf (stderr, "can't read table lensobj data");
    714720      return (FALSE);
    … …  
    741747    }
    742748    /* read StarPar table data : format is irrelevant here */
    743     if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
     749    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, FALSE, &ftable, start, Nrows)) {
    744750      if (VERBOSE) fprintf (stderr, "can't read table starpar data");
    745751      return (FALSE);
    … …  
    772778    }
    773779    /* read GalPhot table data : format is irrelevant here */
    774     if (!gfits_fread_ftable_range (subcat[0].f, FALSE, &ftable, start, Nrows)) {
     780    if (!gfits_fread_ftable_range (subcat[0].f, FALSE, FALSE, &ftable, start, Nrows)) {
    775781      if (VERBOSE) fprintf (stderr, "can't read table galphot data");
    776782      return (FALSE);
    … …  
    842848  }
    843849
     850  if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     851
    844852  Nmeasure_disk_new = MAX (catalog[0].Nmeasure_disk, catalog[0].Nmeasure + catalog[0].Nmeasure_off);
    845853  Nmissing_disk_new = MAX (catalog[0].Nmissing_disk, catalog[0].Nmissing + catalog[0].Nmissing_off);
    … …  
    865873  /* in split mode, we can save only part of the data */
    866874
     875  if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     876
    867877  /*** Average Table ***/
    868878  if ((catalog[0].catflags & DVO_LOAD_AVERAGE) && (catalog[0].average != NULL)) {
    … …  
    890900    }
    891901
     902    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     903
    892904    if (!dvo_catalog_save_subcat (catalog, &ftable, start, Nrows, catalog[0].Naverage_disk, Naverage_disk_new)) {
    893905      fprintf (stderr, "failure writing Average table\n");
    894906      goto failure;
    895907    }
     908
     909    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    896910
    897911    gfits_free_header (&header);
    … …  
    922936    assert (catalog[0].Nmeasure_disk >= catalog[0].Nmeasure_off);
    923937
     938    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     939
    924940    // if we are going to compress, we need to receive unswapped data --
    925941    int swapFromNative = !output_is_compressed (start, Nrows, Nmeasure_disk_new, catalog->catcompress);
    … …  
    930946      goto failure;
    931947    }
     948
     949    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    932950
    933951    // write out Measure table
    … …  
    937955      goto failure;
    938956    }
     957    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     958
    939959
    940960    gfits_free_header (&header);
    … …  
    9861006    int swapFromNative = !output_is_compressed (start, Nrows, Nsecfilt_disk_new, catalog->catcompress);
    9871007
     1008    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
     1009
    9881010    // convert to external table format
    9891011    if (!SecFiltToFtable (&ftable, &secfilt[first], Nrows, catalog[0].catformat, swapFromNative)) {
    … …  
    9911013      goto failure;
    9921014    }
     1015
     1016    if (OHANA_MEMCHECK) ohana_memcheck_func (TRUE);
    9931017
    9941018    // write out SecFilt table
    … …  
    10031027
    10041028  /*** Lensing Table ***/
    1005   if ((catalog[0].catflags & DVO_LOAD_LENSING) && (catalog[0].lensing != NULL)) {
     1029  if ((catalog[0].catflags & DVO_LOAD_LENSING) && catalog[0].lensing && Nlensing_disk_new) {
    10061030
    10071031    off_t first  = 0;                    // first row in memory to write
    … …  
    10341058
    10351059  /*** Lensobj Table ***/
    1036   if ((catalog[0].catflags & DVO_LOAD_LENSOBJ) && (catalog[0].lensobj != NULL)) {
     1060  if ((catalog[0].catflags & DVO_LOAD_LENSOBJ) && catalog[0].lensobj && Nlensobj_disk_new) {
    10371061
    10381062    off_t first  = 0;                    // first row in memory to write
    … …  
    10651089
    10661090  /*** StarPar Table ***/
    1067   if ((catalog[0].catflags & DVO_LOAD_STARPAR) && (catalog[0].starpar != NULL)) {
     1091  if ((catalog[0].catflags & DVO_LOAD_STARPAR) && catalog[0].starpar && Nstarpar_disk_new) {
    10681092
    10691093    off_t first  = 0;                    // first row in memory to write
    … …  
    10961120
    10971121  /*** GalPhot Table ***/
    1098   if ((catalog[0].catflags & DVO_LOAD_GALPHOT) && (catalog[0].galphot != NULL)) {
     1122  if ((catalog[0].catflags & DVO_LOAD_GALPHOT) && catalog[0].galphot && Ngalphot_disk_new) {
    10991123
    11001124    off_t first  = 0;                    // first row in memory to write

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

    r38553 r38986  
    7777    average = Average_PS1_V4alt_ToInternal (tmpAverage, *Naverage);
    7878    free (tmpAverage);
     79    ftable[0].buffer = NULL;
    7980    *format = DVO_FORMAT_PS1_V4;
    8081    return (average);
    … …  
    9192    average = Average_PS1_V5alt_ToInternal (tmpAverage, *Naverage);
    9293    free (tmpAverage);
     94    ftable[0].buffer = NULL;
    9395    *format = DVO_FORMAT_PS1_V5;
    9496    return (average);
    9597  }
    9698
    97 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
    98   if (!strcmp (extname, NAME)) { \
    99     Average_##TYPE *tmpAverage; \
    100       tmpAverage = gfits_table_get_Average_##TYPE (ftable, Naverage, NULL, &nativeBytes); \
    101     if (!tmpAverage) { \
    102       fprintf (stderr, "ERROR: failed to read averages\n"); \
    103       exit (2); \
    104     } \
     99# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
     100  if (!strcmp (extname, NAME)) {                                        \
     101    Average_##TYPE *tmpAverage;                                         \
     102    tmpAverage = gfits_table_get_Average_##TYPE (ftable, Naverage, NULL, &nativeBytes); \
     103    if (!tmpAverage) {                                                  \
     104      fprintf (stderr, "ERROR: failed to read averages\n");             \
     105      exit (2);                                                         \
     106    }                                                                   \
    105107    average = Average_##TYPE##_ToInternal (tmpAverage, *Naverage, primary); \
    106     free (tmpAverage); \
    107     *format = DVO_FORMAT_##FORMAT; \
     108    free (tmpAverage);                                                  \
     109    ftable[0].buffer = NULL;                                            \
     110    *format = DVO_FORMAT_##FORMAT;                                      \
    108111    return (average); }
    109112
    … …  
    141144int AverageToFtable (FTable *ftable, Average *average, off_t Naverage, DVOCatFormat format, SecFilt *primary, int swapFromNative) {
    142145 
    143 # define FORMAT_CASE(FORMAT, TYPE)              \
     146# define FORMAT_CASE(FORMAT, TYPE)                                      \
    144147  case DVO_FORMAT_##FORMAT: {                                           \
    145148    Average_##TYPE *tmpAverage;                                         \
    146       tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
    147         gfits_table_set_Average_##TYPE (ftable, tmpAverage, Naverage, swapFromNative); \
    148           free (tmpAverage);                                            \
    149           break; }
     149    tmpAverage = AverageInternalTo_##TYPE (average, Naverage, primary); \
     150    gfits_table_set_Average_##TYPE (ftable, tmpAverage, Naverage, swapFromNative); \
     151    free (tmpAverage);                                                  \
     152    break; }
    150153 
    151154  /* convert from the internal format */
    … …  
    195198  if (!strcmp (extname, "DVO_MEASURE_PS1_V4") && (ftable[0].header[0].Naxis[0] == 176)) {
    196199    fprintf (stderr, "reading alt PS1_V4 format\n");
     200    myAssert (!nativeBytes, "need to implement optional swap");
    197201    Measure_PS1_V4alt *tmpMeasure;
    198202    tmpMeasure = gfits_table_get_Measure_PS1_V4alt (ftable, Nmeasure, NULL);
    … …  
    204208    measure = Measure_PS1_V4alt_ToInternal (average, tmpMeasure, *Nmeasure);
    205209    free (tmpMeasure);
     210    ftable[0].buffer = NULL;
    206211    *format = DVO_FORMAT_PS1_V4;
    207212    return (measure);
    … …  
    211216  if (!strcmp (extname, "DVO_MEASURE_PS1_V5") && (ftable[0].header[0].Naxis[0] == 232)) {
    212217    fprintf (stderr, "reading alt PS1_V5 format\n");
     218    myAssert (!nativeBytes, "need to implement optional swap");
    213219    Measure_PS1_V5alt *tmpMeasure;
    214220    tmpMeasure = gfits_table_get_Measure_PS1_V5alt (ftable, Nmeasure, NULL);
    … …  
    220226    measure = Measure_PS1_V5alt_ToInternal (average, tmpMeasure, *Nmeasure);
    221227    free (tmpMeasure);
     228    ftable[0].buffer = NULL;
    222229    *format = DVO_FORMAT_PS1_V5;
    223230    return (measure);
    224231  }
    225232
    226 # define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS)         \
     233# define CONVERT_FORMAT(NAME, FORMAT, TYPE, ABS_COORDS)                 \
    227234  if (!strcmp (extname, NAME)) {                                        \
    228235    Measure_##TYPE *tmpMeasure;                                         \
    229       tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL, &nativeBytes); \
    230         if (!tmpMeasure) {                                              \
    231           fprintf (stderr, "ERROR: failed to read measures\n");         \
    232           exit (2);                                                     \
    233         }                                                               \
    234         myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
     236    tmpMeasure = gfits_table_get_Measure_##TYPE (ftable, Nmeasure, NULL, &nativeBytes); \
     237    if (!tmpMeasure) {                                                  \
     238      fprintf (stderr, "ERROR: failed to read measures\n");             \
     239      exit (2);                                                         \
     240    }                                                                   \
     241    myAssert (ABS_COORDS || average, "conversion to internal needs average table"); \
    235242    measure = Measure_##TYPE##_ToInternal (average, tmpMeasure, *Nmeasure); \
    236243    free (tmpMeasure);                                                  \
     244    ftable[0].buffer = NULL;                                            \
    237245    *format = DVO_FORMAT_##FORMAT;                                      \
    238246    return (measure); }
    … …  
    272280int MeasureToFtable (FTable *ftable, Average *average, Measure *measure, off_t Nmeasure, DVOCatFormat format, int swapFromNative) {
    273281
    274 # define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)          \
    275     case DVO_FORMAT_##FORMAT: { \
    276       Measure_##TYPE *tmpMeasure; \
    277       myAssert (ABS_COORDS || average, "conversion from internal needs average table"); \
    278       tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
    279         gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure, swapFromNative); \
    280       free (tmpMeasure); \
    281       break; }
     282# define FORMAT_CASE(FORMAT, TYPE, ABS_COORDS)                          \
     283  case DVO_FORMAT_##FORMAT: {                                           \
     284    Measure_##TYPE *tmpMeasure;                                         \
     285    myAssert (ABS_COORDS || average, "conversion from internal needs average table"); \
     286    tmpMeasure = MeasureInternalTo_##TYPE (average, measure, Nmeasure); \
     287    gfits_table_set_Measure_##TYPE (ftable, tmpMeasure, Nmeasure, swapFromNative); \
     288    free (tmpMeasure);                                                  \
     289    break; }
    282290
    283291  /* convert from the internal format */
    … …  
    322330  }
    323331
    324 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     332# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    325333  if (!strcmp (extname, NAME)) {                                        \
    326334    fprintf (stderr, "ERROR: format %s not defined for missing, skipping\n", NAME); \
    327     *Nmissing = 0; \
    328     return NULL; \
    329   }
    330 
    331 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     335    *Nmissing = 0;                                                      \
     336    return NULL;                                                        \
     337  }
     338
     339# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    332340  if (!strcmp (extname, NAME)) {                                        \
    333341    Missing_##TYPE *tmpMissing;                                         \
    … …  
    337345      exit (2);                                                         \
    338346    }                                                                   \
    339     missing = Missing_##TYPE##_ToInternal (tmpMissing, *Nmissing); \
     347    missing = Missing_##TYPE##_ToInternal (tmpMissing, *Nmissing);      \
    340348    free (tmpMissing);                                                  \
     349    ftable[0].buffer = NULL;                                            \
    341350    *format = DVO_FORMAT_##FORMAT;                                      \
    342351    return (missing); }
    … …  
    408417    secfilt = SecFilt_PS1_V5alt_ToInternal (tmpSecFilt, *Nsecfilt);
    409418    free (tmpSecFilt);
     419    ftable[0].buffer = NULL;
    410420    *format = DVO_FORMAT_PS1_V5;
    411421    return (secfilt);
    … …  
    413423
    414424
    415 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
    416   if (!strcmp (extname, NAME)) { \
    417     SecFilt_##TYPE *tmpSecFilt; \
     425# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
     426  if (!strcmp (extname, NAME)) {                                        \
     427    SecFilt_##TYPE *tmpSecFilt;                                         \
    418428    tmpSecFilt = gfits_table_get_SecFilt_##TYPE (ftable, Nsecfilt, NULL, &nativeBytes); \
    419     if (!tmpSecFilt) { \
    420       fprintf (stderr, "ERROR: failed to read secfilts\n"); \
    421       exit (2); \
    422     } \
    423     secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, *Nsecfilt); \
    424     free (tmpSecFilt); \
    425     *format = DVO_FORMAT_##FORMAT; \
     429    if (!tmpSecFilt) {                                                  \
     430      fprintf (stderr, "ERROR: failed to read secfilts\n");             \
     431      exit (2);                                                         \
     432    }                                                                   \
     433    secfilt = SecFilt_##TYPE##_ToInternal (tmpSecFilt, *Nsecfilt);      \
     434    free (tmpSecFilt);                                                  \
     435    ftable[0].buffer = NULL;                                            \
     436    *format = DVO_FORMAT_##FORMAT;                                      \
    426437    return (secfilt); }
    427438
    … …  
    459470int SecFiltToFtable (FTable *ftable, SecFilt *secfilt, off_t Nsecfilt, DVOCatFormat format, int swapFromNative) {
    460471
    461 # define FORMAT_CASE(FORMAT, TYPE) \
    462     case DVO_FORMAT_##FORMAT: { \
    463       SecFilt_##TYPE *tmpSecFilt; \
    464       tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt); \
    465         gfits_table_set_SecFilt_##TYPE (ftable, tmpSecFilt, Nsecfilt, swapFromNative); \
    466       free (tmpSecFilt); \
    467       break; }
     472# define FORMAT_CASE(FORMAT, TYPE)                                      \
     473  case DVO_FORMAT_##FORMAT: {                                           \
     474    SecFilt_##TYPE *tmpSecFilt;                                         \
     475    tmpSecFilt = SecFiltInternalTo_##TYPE (secfilt, Nsecfilt);          \
     476    gfits_table_set_SecFilt_##TYPE (ftable, tmpSecFilt, Nsecfilt, swapFromNative); \
     477    free (tmpSecFilt);                                                  \
     478    break; }
    468479
    469480  /* convert from the internal format */
    … …  
    517528    lensing = Lensing_PS1_V5_R0_ToInternal (tmpLensing, *Nlensing);
    518529    free (tmpLensing);                                                 
     530    ftable[0].buffer = NULL;
    519531    *format = DVO_FORMAT_PS1_V5;                                       
    520532    return (lensing); }
    … …  
    529541    lensing = Lensing_PS1_V5_R1_ToInternal (tmpLensing, *Nlensing);
    530542    free (tmpLensing);                                                 
     543    ftable[0].buffer = NULL;
    531544    *format = DVO_FORMAT_PS1_V5;                                       
    532545    return (lensing); }
    … …  
    541554    lensing = Lensing_PS1_V5_R2_ToInternal (tmpLensing, *Nlensing);
    542555    free (tmpLensing);                                                 
     556    ftable[0].buffer = NULL;
    543557    *format = DVO_FORMAT_PS1_V5;                                       
    544558    return (lensing); }
    545559
    546 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     560# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    547561  if (!strcmp (extname, NAME)) {                                        \
    548562    fprintf (stderr, "ERROR: format %s not defined for lensing, skipping\n", NAME); \
    549     *Nlensing = 0; \
    550     return NULL; \
    551   }
    552 
    553 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     563    *Nlensing = 0;                                                      \
     564    return NULL;                                                        \
     565  }
     566
     567# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    554568  if (!strcmp (extname, NAME)) {                                        \
    555569    Lensing_##TYPE *tmpLensing;                                         \
    … …  
    559573      exit (2);                                                         \
    560574    }                                                                   \
    561     lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing); \
     575    lensing = Lensing_##TYPE##_ToInternal (tmpLensing, *Nlensing);      \
    562576    free (tmpLensing);                                                  \
     577    ftable[0].buffer = NULL;                                            \
    563578    *format = DVO_FORMAT_##FORMAT;                                      \
    564579    return (lensing); }
    … …  
    599614int LensingToFtable (FTable *ftable, Lensing *lensing, off_t Nlensing, DVOCatFormat format, int swapFromNative) {
    600615
    601 # define FORMAT_CASE(FORMAT, TYPE)              \
    602     case DVO_FORMAT_##FORMAT: { \
    603       Lensing_##TYPE *tmpLensing; \
    604       tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing); \
    605         gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing, swapFromNative); \
    606       free (tmpLensing); \
    607       break; }
     616# define FORMAT_CASE(FORMAT, TYPE)                                      \
     617  case DVO_FORMAT_##FORMAT: {                                           \
     618    Lensing_##TYPE *tmpLensing;                                         \
     619    tmpLensing = LensingInternalTo_##TYPE (lensing, Nlensing);          \
     620    gfits_table_set_Lensing_##TYPE (ftable, tmpLensing, Nlensing, swapFromNative); \
     621    free (tmpLensing);                                                  \
     622    break; }
    608623
    609624  /* convert from the internal format */
    … …  
    656671    lensobj = Lensobj_PS1_V5_R0_ToInternal (tmpLensobj, *Nlensobj);
    657672    free (tmpLensobj);                                                 
     673    ftable[0].buffer = NULL;
    658674    *format = DVO_FORMAT_PS1_V5;                                       
    659675    return (lensobj); }
    660676
    661 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     677# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    662678  if (!strcmp (extname, NAME)) {                                        \
    663679    fprintf (stderr, "ERROR: format %s not defined for lensobj, skipping\n", NAME); \
    664     *Nlensobj = 0; \
    665     return NULL; \
    666   }
    667 
    668 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     680    *Nlensobj = 0;                                                      \
     681    return NULL;                                                        \
     682  }
     683
     684# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    669685  if (!strcmp (extname, NAME)) {                                        \
    670686    Lensobj_##TYPE *tmpLensobj;                                         \
    … …  
    674690      exit (2);                                                         \
    675691    }                                                                   \
    676     lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj); \
     692    lensobj = Lensobj_##TYPE##_ToInternal (tmpLensobj, *Nlensobj);      \
    677693    free (tmpLensobj);                                                  \
     694    ftable[0].buffer = NULL;                                            \
    678695    *format = DVO_FORMAT_##FORMAT;                                      \
    679696    return (lensobj); }
    … …  
    714731int LensobjToFtable (FTable *ftable, Lensobj *lensobj, off_t Nlensobj, DVOCatFormat format, int swapFromNative) {
    715732
    716 # define FORMAT_CASE(FORMAT, TYPE)              \
    717     case DVO_FORMAT_##FORMAT: { \
    718       Lensobj_##TYPE *tmpLensobj; \
    719       tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj); \
    720         gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj, swapFromNative); \
    721       free (tmpLensobj); \
    722       break; }
     733# define FORMAT_CASE(FORMAT, TYPE)                                      \
     734  case DVO_FORMAT_##FORMAT: {                                           \
     735    Lensobj_##TYPE *tmpLensobj;                                         \
     736    tmpLensobj = LensobjInternalTo_##TYPE (lensobj, Nlensobj);          \
     737    gfits_table_set_Lensobj_##TYPE (ftable, tmpLensobj, Nlensobj, swapFromNative); \
     738    free (tmpLensobj);                                                  \
     739    break; }
    723740
    724741  /* convert from the internal format */
    … …  
    762779  }
    763780
    764 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     781# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    765782  if (!strcmp (extname, NAME)) {                                        \
    766783    fprintf (stderr, "ERROR: format %s not defined for starpar, skipping\n", NAME); \
    767     *Nstarpar = 0; \
    768     return NULL; \
    769   }
    770 
    771 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     784    *Nstarpar = 0;                                                      \
     785    return NULL;                                                        \
     786  }
     787 
     788# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    772789  if (!strcmp (extname, NAME)) {                                        \
    773790    StarPar_##TYPE *tmpStarPar;                                         \
    … …  
    777794      exit (2);                                                         \
    778795    }                                                                   \
    779     starpar = StarPar_##TYPE##_ToInternal (tmpStarPar, *Nstarpar); \
     796    starpar = StarPar_##TYPE##_ToInternal (tmpStarPar, *Nstarpar);      \
    780797    free (tmpStarPar);                                                  \
     798    ftable[0].buffer = NULL;                                            \
    781799    *format = DVO_FORMAT_##FORMAT;                                      \
    782800    return (starpar); }
    … …  
    817835int StarParToFtable (FTable *ftable, StarPar *starpar, off_t Nstarpar, DVOCatFormat format, int swapFromNative) {
    818836
    819 # define FORMAT_CASE(FORMAT, TYPE)              \
    820     case DVO_FORMAT_##FORMAT: { \
    821       StarPar_##TYPE *tmpStarPar; \
    822       tmpStarPar = StarParInternalTo_##TYPE (starpar, Nstarpar); \
    823         gfits_table_set_StarPar_##TYPE (ftable, tmpStarPar, Nstarpar, swapFromNative); \
    824       free (tmpStarPar); \
    825       break; }
     837# define FORMAT_CASE(FORMAT, TYPE)                                      \
     838  case DVO_FORMAT_##FORMAT: {                                           \
     839    StarPar_##TYPE *tmpStarPar;                                         \
     840    tmpStarPar = StarParInternalTo_##TYPE (starpar, Nstarpar);          \
     841    gfits_table_set_StarPar_##TYPE (ftable, tmpStarPar, Nstarpar, swapFromNative); \
     842    free (tmpStarPar);                                                  \
     843    break; }
    826844
    827845  /* convert from the internal format */
    … …  
    866884  }
    867885
    868 # define SKIPPING_FORMAT(NAME, FORMAT, TYPE)            \
     886  if (!strcmp (extname, "DVO_GALPHOT_PS1_V5") && (ftable[0].header[0].Naxis[0] == 72)) {
     887    GalPhot_PS1_V5_R0 *tmpGalPhot;                                             
     888    tmpGalPhot = gfits_table_get_GalPhot_PS1_V5_R0 (ftable, Ngalphot, NULL, &nativeBytes);
     889    if (!tmpGalPhot) {                                                 
     890      fprintf (stderr, "ERROR: failed to read galphots\n");             
     891      exit (2);                                                         
     892    }                                                                   
     893    galphot = GalPhot_PS1_V5_R0_ToInternal (tmpGalPhot, *Ngalphot);
     894    free (tmpGalPhot);                                                 
     895    ftable[0].buffer = NULL;
     896    *format = DVO_FORMAT_PS1_V5;                                       
     897    return (galphot);
     898  }
     899
     900# define SKIPPING_FORMAT(NAME, FORMAT, TYPE)                            \
    869901  if (!strcmp (extname, NAME)) {                                        \
    870902    fprintf (stderr, "ERROR: format %s not defined for galphot, skipping\n", NAME); \
    871     *Ngalphot = 0; \
    872     return NULL; \
    873   }
    874 
    875 # define CONVERT_FORMAT(NAME, FORMAT, TYPE)             \
     903    *Ngalphot = 0;                                                      \
     904    return NULL;                                                        \
     905  }
     906
     907# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
    876908  if (!strcmp (extname, NAME)) {                                        \
    877909    GalPhot_##TYPE *tmpGalPhot;                                         \
    … …  
    881913      exit (2);                                                         \
    882914    }                                                                   \
    883     galphot = GalPhot_##TYPE##_ToInternal (tmpGalPhot, *Ngalphot); \
     915    galphot = GalPhot_##TYPE##_ToInternal (tmpGalPhot, *Ngalphot);      \
    884916    free (tmpGalPhot);                                                  \
     917    ftable[0].buffer = NULL;                                            \
    885918    *format = DVO_FORMAT_##FORMAT;                                      \
    886919    return (galphot); }
    … …  
    907940  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_V3",          PS1_V3,          PS1_V3);
    908941  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_V4",          PS1_V4,          PS1_V4);
    909   CONVERT_FORMAT  ("DVO_GALPHOT_PS1_V5",          PS1_V5,          PS1_V5);
     942  CONVERT_FORMAT  ("DVO_GALPHOT_PS1_V5",          PS1_V5,          PS1_V5_R1);
    910943  SKIPPING_FORMAT ("DVO_GALPHOT_PS1_SIM",         PS1_SIM,         PS1_SIM);
    911944# undef CONVERT_FORMAT
    … …  
    921954int GalPhotToFtable (FTable *ftable, GalPhot *galphot, off_t Ngalphot, DVOCatFormat format, int swapFromNative) {
    922955
    923 # define FORMAT_CASE(FORMAT, TYPE)              \
    924     case DVO_FORMAT_##FORMAT: { \
    925       GalPhot_##TYPE *tmpGalPhot; \
    926       tmpGalPhot = GalPhotInternalTo_##TYPE (galphot, Ngalphot); \
    927         gfits_table_set_GalPhot_##TYPE (ftable, tmpGalPhot, Ngalphot, swapFromNative); \
    928       free (tmpGalPhot); \
    929       break; }
     956# define FORMAT_CASE(FORMAT, TYPE)                                      \
     957  case DVO_FORMAT_##FORMAT: {                                           \
     958    GalPhot_##TYPE *tmpGalPhot;                                         \
     959    tmpGalPhot = GalPhotInternalTo_##TYPE (galphot, Ngalphot);          \
     960    gfits_table_set_GalPhot_##TYPE (ftable, tmpGalPhot, Ngalphot, swapFromNative); \
     961    free (tmpGalPhot);                                                  \
     962    break; }
    930963
    931964  /* convert from the internal format */
    … …  
    946979//    FORMAT_CASE (PS1_V3,          PS1_V3);
    947980//    FORMAT_CASE (PS1_V4,          PS1_V4);
    948       FORMAT_CASE (PS1_V5,          PS1_V5);
     981      FORMAT_CASE (PS1_V5,          PS1_V5_R1);
    949982# undef FORMAT_CASE
    950983
    … …  
    9901023  }
    9911024
    992 # define CONVERT_FORMAT(NAME, FORMAT, TYPE) \
    993   if (!strcmp (extname, NAME)) { \
    994     Image_##TYPE *tmpimage; \
    995     *format = DVO_FORMAT_##FORMAT; \
     1025# define CONVERT_FORMAT(NAME, FORMAT, TYPE)                             \
     1026  if (!strcmp (extname, NAME)) {                                        \
     1027    Image_##TYPE *tmpimage;                                             \
     1028    *format = DVO_FORMAT_##FORMAT;                                      \
    9961029    tmpimage = gfits_table_get_Image_##TYPE (ftable, &Nimage, NULL, NULL); \
    997     if (!tmpimage) { \
    998       fprintf (stderr, "ERROR: failed to read images\n"); \
    999       exit (2); \
    1000     } \
     1030    if (!tmpimage) {                                                    \
     1031      fprintf (stderr, "ERROR: failed to read images\n");               \
     1032      exit (2);                                                         \
     1033    }                                                                   \
    10011034    off_t Nalloc = gfits_data_pad_size(Nimage*sizeof(Image));           \
    10021035    ftable[0].buffer = (char *) Image_##TYPE##_ToInternal (tmpimage, Nimage, Nalloc); \
    1003     free (tmpimage); \
    1004     gfits_free_header (theader); \
    1005     gfits_table_mkheader_Image (theader); \
    1006     gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage); \
    1007     theader[0].Naxis[1] = Nimage; \
    1008     ftable[0].datasize = gfits_data_size (theader); \
     1036    free (tmpimage);                                                    \
     1037    gfits_free_header (theader);                                        \
     1038    gfits_table_mkheader_Image (theader);                               \
     1039    gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage);            \
     1040    theader[0].Naxis[1] = Nimage;                                       \
     1041    ftable[0].datasize = gfits_data_size (theader);                     \
    10091042    return (TRUE); }
    10101043
    … …  
    10351068  Nimage = theader[0].Naxis[1];
    10361069
    1037 # define FORMAT_CASE(FORMAT, TYPE)              \
    1038   case DVO_FORMAT_##FORMAT: {                   \
     1070# define FORMAT_CASE(FORMAT, TYPE)                                      \
     1071  case DVO_FORMAT_##FORMAT: {                                           \
    10391072    Image_##TYPE *tmpImage;                                             \
    1040       tmpImage = ImageInternalTo_##TYPE ((Image *) ftable[0].buffer, Nimage); \
    1041         free (ftable[0].buffer);                                        \
    1042         gfits_free_header (ftable->header);                             \
    1043         gfits_table_set_Image_##TYPE (ftable, tmpImage, Nimage, TRUE);  \
    1044           free (tmpImage);                                              \
    1045           break; }
     1073    tmpImage = ImageInternalTo_##TYPE ((Image *) ftable[0].buffer, Nimage); \
     1074    free (ftable[0].buffer);                                            \
     1075    gfits_free_header (ftable->header);                                 \
     1076    gfits_table_set_Image_##TYPE (ftable, tmpImage, Nimage, TRUE);      \
     1077    free (tmpImage);                                                    \
     1078    break; }
    10461079
    10471080  /* convert from the internal format */
    10481081  switch (format) {
    1049       FORMAT_CASE (ELIXIR,          Elixir);
    1050       FORMAT_CASE (LONEOS,          Loneos);
    1051       FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
    1052       FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
    1053       FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
    1054       FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
    1055       FORMAT_CASE (PS1_V1,          PS1_V1);
    1056       FORMAT_CASE (PS1_V2,          PS1_V2);
    1057       FORMAT_CASE (PS1_V3,          PS1_V3);
    1058       FORMAT_CASE (PS1_V4,          PS1_V4);
    1059       FORMAT_CASE (PS1_V5,          PS1_V5);
    1060       FORMAT_CASE (PS1_REF,         PS1_REF);
    1061       FORMAT_CASE (PS1_SIM,         PS1_SIM);
     1082    FORMAT_CASE (ELIXIR,            Elixir);
     1083    FORMAT_CASE (LONEOS,            Loneos);
     1084    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     1085    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     1086    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     1087    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
     1088    FORMAT_CASE (PS1_V1,          PS1_V1);
     1089    FORMAT_CASE (PS1_V2,          PS1_V2);
     1090    FORMAT_CASE (PS1_V3,          PS1_V3);
     1091    FORMAT_CASE (PS1_V4,          PS1_V4);
     1092    FORMAT_CASE (PS1_V5,          PS1_V5);
     1093    FORMAT_CASE (PS1_REF,         PS1_REF);
     1094    FORMAT_CASE (PS1_SIM,         PS1_SIM);
    10621095
    10631096# undef FORMAT_CASE
    … …  
    10761109  Nrow = vtable[0].Nrow;
    10771110
    1078 # define FORMAT_CASE(FORMAT, TYPE) \
    1079   case DVO_FORMAT_##FORMAT: { \
    1080       Image_##TYPE *tmpImage; \
    1081       /* convert table rows from internal to external format */ \
    1082       for (i = 0; i < Nrow; i++) { \
    1083           tmpImage = ImageInternalTo_##TYPE ((Image *) vtable[0].buffer[i], 1); \
    1084           gfits_convert_Image_##TYPE (tmpImage, sizeof(Image_##TYPE), 1); \
    1085           free (vtable[0].buffer[i]); \
    1086           vtable[0].buffer[i] = (char *) tmpImage; \
    1087       } \
    1088       /* convert header from old format to new format */ \
    1089       gfits_scan (theader, "NAXIS2", OFF_T_FMT, 1,  &Nimage); \
    1090       gfits_free_header (theader); \
    1091       gfits_table_mkheader_Image_##TYPE (theader); \
    1092       gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage); \
    1093       theader[0].Naxis[1] = Nimage; \
    1094       vtable[0].datasize = gfits_data_size (theader); \
    1095       return (TRUE); }
     1111# define FORMAT_CASE(FORMAT, TYPE)                                      \
     1112  case DVO_FORMAT_##FORMAT: {                                           \
     1113    Image_##TYPE *tmpImage;                                             \
     1114    /* convert table rows from internal to external format */           \
     1115    for (i = 0; i < Nrow; i++) {                                        \
     1116      tmpImage = ImageInternalTo_##TYPE ((Image *) vtable[0].buffer[i], 1); \
     1117      gfits_convert_Image_##TYPE (tmpImage, sizeof(Image_##TYPE), 1);   \
     1118      free (vtable[0].buffer[i]);                                       \
     1119      vtable[0].buffer[i] = (char *) tmpImage;                          \
     1120    }                                                                   \
     1121    /* convert header from old format to new format */                  \
     1122    gfits_scan (theader, "NAXIS2", OFF_T_FMT, 1,  &Nimage);             \
     1123    gfits_free_header (theader);                                        \
     1124    gfits_table_mkheader_Image_##TYPE (theader);                        \
     1125    gfits_modify (theader, "NAXIS2", OFF_T_FMT, 1,  Nimage);            \
     1126    theader[0].Naxis[1] = Nimage;                                       \
     1127    vtable[0].datasize = gfits_data_size (theader);                     \
     1128    return (TRUE); }
    10961129
    10971130
    10981131  /* convert from the internal format */
    10991132  switch (format) {
    1100       FORMAT_CASE (ELIXIR,          Elixir);
    1101       FORMAT_CASE (LONEOS,          Loneos);
    1102       FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
    1103       FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
    1104       FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
    1105       FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
    1106       FORMAT_CASE (PS1_V1,          PS1_V1);
    1107       FORMAT_CASE (PS1_V2,          PS1_V2);
    1108       FORMAT_CASE (PS1_V3,          PS1_V3);
    1109       FORMAT_CASE (PS1_V4,          PS1_V4);
    1110       FORMAT_CASE (PS1_V5,          PS1_V5);
    1111       FORMAT_CASE (PS1_REF,         PS1_REF);
    1112       FORMAT_CASE (PS1_SIM,         PS1_SIM);
     1133    FORMAT_CASE (ELIXIR,            Elixir);
     1134    FORMAT_CASE (LONEOS,            Loneos);
     1135    FORMAT_CASE (PANSTARRS_DEV_0, Panstarrs_DEV_0);
     1136    FORMAT_CASE (PANSTARRS_DEV_1, Panstarrs_DEV_1);
     1137    FORMAT_CASE (PS1_DEV_1,       PS1_DEV_1);
     1138    FORMAT_CASE (PS1_DEV_2,       PS1_DEV_2);
     1139    FORMAT_CASE (PS1_V1,          PS1_V1);
     1140    FORMAT_CASE (PS1_V2,          PS1_V2);
     1141    FORMAT_CASE (PS1_V3,          PS1_V3);
     1142    FORMAT_CASE (PS1_V4,          PS1_V4);
     1143    FORMAT_CASE (PS1_V5,          PS1_V5);
     1144    FORMAT_CASE (PS1_REF,         PS1_REF);
     1145    FORMAT_CASE (PS1_SIM,         PS1_SIM);
    11131146
    11141147# undef FORMAT_CASE

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

    r38553 r38986  
    218218    out[i].catID         = in[i].catID;
    219219    out[i].extID         = in[i].extID;
    220     out[i].extIDgc       = in[i].extIDgc;
     220
     221    out[i].uRgal         = in[i].uRgal;
     222    out[i].uDgal         = in[i].uDgal;
    221223  }
    222224  return (out);
    … …  
    286288    out[i].catID          = in[i].catID;
    287289    out[i].extID          = in[i].extID;
    288     out[i].extIDgc        = in[i].extIDgc;
     290
     291    out[i].uRgal         = in[i].uRgal;
     292    out[i].uDgal         = in[i].uDgal;
    289293  }
    290294  return (out);
    … …  
    979983}
    980984
    981 GalPhot *GalPhot_PS1_V5_ToInternal (GalPhot_PS1_V5 *in, off_t Nvalues) {
     985GalPhot *GalPhot_PS1_V5_R1_ToInternal (GalPhot_PS1_V5_R1 *in, off_t Nvalues) {
    982986
    983987  off_t i;
    … …  
    10131017}
    10141018
    1015 GalPhot_PS1_V5 *GalPhotInternalTo_PS1_V5 (GalPhot *in, off_t Nvalues) {
    1016 
    1017   off_t i;
    1018   GalPhot_PS1_V5 *out;
    1019 
    1020   ALLOCATE_ZERO (out, GalPhot_PS1_V5, Nvalues);
     1019GalPhot *GalPhot_PS1_V5_R0_ToInternal (GalPhot_PS1_V5_R0 *in, off_t Nvalues) {
     1020
     1021  off_t i;
     1022  GalPhot *out;
     1023
     1024  ALLOCATE_ZERO (out, GalPhot, Nvalues);
     1025
     1026  for (i = 0; i < Nvalues; i++) {
     1027    dvo_galphot_init (&out[i]);
     1028
     1029    out[i].Xfit          = in[i].Xfit;
     1030    out[i].Yfit          = in[i].Yfit;
     1031    out[i].mag           = in[i].mag;
     1032    out[i].magErr        = in[i].magErr;
     1033    out[i].majorAxis     = in[i].majorAxis;
     1034    out[i].minorAxis     = in[i].minorAxis;
     1035    out[i].majorAxisErr  = in[i].majorAxisErr;
     1036    out[i].minorAxisErr  = in[i].minorAxisErr;
     1037    out[i].theta         = in[i].theta;
     1038    out[i].thetaErr      = in[i].thetaErr;
     1039    out[i].index         = in[i].index;
     1040    out[i].chisq         = in[i].chisq;
     1041    out[i].Npix          = in[i].Npix;
     1042    out[i].objID         = in[i].objID;
     1043    out[i].catID         = in[i].catID;
     1044    out[i].detID         = in[i].detID;
     1045    out[i].imageID       = in[i].imageID;
     1046//  out[i].averef        = in[i].averef;
     1047    out[i].photcode      = in[i].photcode;
     1048    out[i].modelType     = in[i].modelType;
     1049  }
     1050  return (out);
     1051}
     1052
     1053GalPhot_PS1_V5_R1 *GalPhotInternalTo_PS1_V5_R1 (GalPhot *in, off_t Nvalues) {
     1054
     1055  off_t i;
     1056  GalPhot_PS1_V5_R1 *out;
     1057
     1058  ALLOCATE_ZERO (out, GalPhot_PS1_V5_R1, Nvalues);
    10211059
    10221060  for (i = 0; i < Nvalues; i++) {
    … …  
    13181356    out[i].catID          = in[i].catID;
    13191357    out[i].extID          = in[i].extID;
    1320     out[i].extIDgc        = in[i].extIDgc;
    13211358  }
    13221359  return (out);

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

    r38970 r38986  
    205205/* return equivalent photcode.code for given code */
    206206int GetPhotcodeEquivCodebyCode (int code) {
     207  myAssert (photcodes, "photcodes not loaded");
    207208 
    208209  int entry;
    … …  
    218219// returns Nsec if code is PRI/SEC, else -1
    219220int GetPhotcodeNsec (int code) {
     221  myAssert (photcodes, "photcodes not loaded");
    220222 
    221223  int Nsec;
    … …  
    230232/* Nsec of 0 is PRI */
    231233PhotCode *GetPhotcodebyNsec (int Nsec) {
     234  myAssert (photcodes, "photcodes not loaded");
    232235 
    233236  int Ncode;
    … …  
    245248
    246249int GetPhotcodeNsecfilt () {
     250  myAssert (photcodes, "photcodes not loaded");
    247251  return (photcodes[0].Nsecfilt);
    248252}
    … …  
    745749  }
    746750  return (Mstdev);
     751}
     752
     753// return the number of detections in this filter (gpc1)
     754int PhotNcode (PhotCode *code, Average *average, SecFilt *secfilt) {
     755
     756  if (code == NULL) return 0;
     757
     758  int Ns = photcodes[0].hashNsec[code[0].code];
     759  if (Ns == -1) return 0;
     760
     761  return secfilt[Ns].Ncode;
     762}
     763
     764// return the number of detections in this filter (gpc1)
     765int PhotSecfiltFlags (PhotCode *code, Average *average, SecFilt *secfilt) {
     766
     767  if (code == NULL) return 0;
     768
     769  int Ns = photcodes[0].hashNsec[code[0].code];
     770  if (Ns == -1) return 0;
     771
     772  return secfilt[Ns].flags;
    747773}
    748774

  • trunk/Ohana/src/libfits/Makefile

    r38441 r38986  
    2525TEST_CPPFLAGS = $(BASE_CPPFLAGS)
    2626TEST_LDFLAGS  = $(BASE_LDFLAGS) -lFITS -lohana -ltap_ohana
    27 
    2827
    2928TESTXTRA = tcomptiming

  • trunk/Ohana/src/libfits/extern/gzip.c

    r38441 r38986  
    215215  err = inflate(&stream, Z_FINISH);
    216216  if (err != Z_STREAM_END) {
     217    if (err == Z_DATA_ERROR) {
     218      fprintf (stderr, "compressed data is corrupted\n");
     219      ESCAPE(err);
     220    }
    217221    inflateEnd(&stream);
    218222    if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) ESCAPE (Z_DATA_ERROR);

  • trunk/Ohana/src/libfits/header/F_H_field.c

    r29537 r38986  
    3333  }
    3434
    35   if (N < 0) {
     35  if (N <= 0) {
    3636    /* count the entries */
    3737    Nfound = 0;

  • trunk/Ohana/src/libfits/include/gfitsio.h

    r38553 r38986  
    237237int     gfits_fread_ftable             PROTO((FILE *f, FTable *ftable, char *extname));
    238238int     gfits_fread_ftable_data        PROTO((FILE *f, FTable *ftable, int padIfShort));
    239 int     gfits_fread_ftable_range       PROTO((FILE *f, int padIfShort, FTable *ftable, off_t start, off_t Nrows));
     239int     gfits_fread_ftable_range       PROTO((FILE *f, int padIfShort, int noSeek, FTable *ftable, off_t start, off_t Nrows));
    240240int     gfits_fread_vtable             PROTO((FILE *f, VTable *vtable, char *extname, off_t Nrow, off_t *row));
    241241int     gfits_fread_vtable_range       PROTO((FILE *f, VTable *vtable, off_t start, off_t Nrows));

  • trunk/Ohana/src/libfits/matrix/F_compress_data.c

    r38441 r38986  
    119119      return (FALSE);
    120120    }
     121    if (Nout > *Nzdata) {
     122      fprintf (stderr, "buffer overrun! %d out, %d available\n", Nout, *Nzdata);
     123      return FALSE;
     124    }
    121125    *Nzdata = Nout;
    122126    return TRUE;

  • trunk/Ohana/src/libfits/table/F_compress_T.c

    r38553 r38986  
    211211
    212212  // allocate the intermediate storage buffers
    213   int Nzdata_alloc = max_width*ztilelen + 100;
     213  int Nzdata_alloc = 2*max_width*ztilelen + 100;
    214214  ALLOCATE (raw,   char, max_width*ztilelen);
    215215  ALLOCATE (zdata, char, Nzdata_alloc);
    … …  
    223223  gettimeofday (&startTimer, (void *) NULL);
    224224
     225  // ohana_memcheck (TRUE);
     226
    225227  // compress the data : copy into a tile, compress the tile, then add to the output table
    226228  // each tile -> 1 row of the output table
    … …  
    243245      }
    244246     
     247      // ohana_memcheck (TRUE);
     248
    245249      // XXX TIMER 2a
    246250      gettimeofday (&stopTimer, (void *) NULL);
    … …  
    260264      }
    261265
     266      // ohana_memcheck (TRUE);
    262267      // optname, optvalue = NULL, Noptions = 0
    263268     

  • trunk/Ohana/src/libfits/table/F_read_T.c

    r38441 r38986  
    6262
    6363/*********************** fits read ftable data ***********************************/
    64 int gfits_fread_ftable_range (FILE *f, int padIfShort, FTable *table, off_t start, off_t Nrows) {
     64int gfits_fread_ftable_range (FILE *f, int padIfShort, int noSeek, FTable *table, off_t start, off_t Nrows) {
    6565
    6666  off_t Nbytes, Nread, Nskip, Nx, Ny;
    … …  
    7979  Nskip = start * Nx;
    8080  Nbytes = Nrows * Nx;
    81   ALLOCATE (table[0].buffer, char, MAX (Nbytes, 1));
    82 
    83   fseeko (f, Nskip, SEEK_CUR);
     81
     82  if (table[0].buffer) {
     83    if (table[0].datasize < Nbytes) {
     84      REALLOCATE (table[0].buffer, char, MAX (Nbytes, 1));
     85    }
     86  } else {
     87    ALLOCATE (table[0].buffer, char, MAX (Nbytes, 1));
     88  }
     89
     90  if (!noSeek) {
     91    fseeko (f, Nskip, SEEK_CUR);
     92  }
    8493
    8594  Nread = fread (table[0].buffer, sizeof (char), Nbytes, f);

  • trunk/Ohana/src/libfits/test/tcomptiming.c

    r38553 r38986  
    2525    int Ntile = pow (10.0, lNtile);
    2626    fprintf (stderr, "--- Ntile = %d ---\n", Ntile);
    27     test_compress_timing ("NONE_2", Ntile);
     27    test_compress_timing ("GZIP_2", Ntile);
    2828    gfits_compress_timing();
    2929    gfits_uncompress_timing();

  • trunk/Ohana/src/libkapa/Makefile

    r38473 r38986  
    2020install: $(DESTINC)/kapa.h $(DESTLIB)/libkapa.a $(DESTLIB)/libkapa.$(DLLTYPE)
    2121libkapa: $(LIB)/libkapa.$(ARCH).a $(LIB)/libkapa.$(ARCH).$(DLLTYPE)
     22
     23ROTFONT:
     24        cd rotfont && $(MAKE) all
    2225
    2326INCS = $(DESTINC)/kapa.h
    … …  
    4346$(SRC)/PSRotFont.$(ARCH).o
    4447
    45 $(OBJS): $(INCS)
     48$(INCS): ROTFONT
     49$(OBJS): $(INCS)
    4650$(DRAW): $(INCS)
    4751

  • trunk/Ohana/src/libkapa/include/alphabet.h

    r5854 r38986  
     1
     2# if (0)
     3# include "../rotfont/times8.h"
     4
     5# define DEFFONT 1
     6static FontSet HardwiredFonts[] = {
     7  {times8font,  "times", 8}
     8};
     9# endif
     10
     11# if (1)
    112# include "../rotfont/times8.h"
    213# include "../rotfont/times12.h"
    … …  
    4960  {symbol24font, "symbol", 24}
    5061};
     62# endif
    5163
    5264/* put these as static in RotFont.c with accessor functions */

  • trunk/Ohana/src/libkapa/include/kapa.h

    r38461 r38986  
    9393  double labelPadXm, labelPadYm, labelPadXp, labelPadYp;
    9494  double padXm, padXp, padYm, padYp;
     95  double fLabelRangeXm, fLabelRangeXp, fLabelRangeYm, fLabelRangeYp;
     96  double fMinorXm, fMinorXp, fMinorYm, fMinorYp;
    9597  Coords coords;
    9698  int flipeast, flipnorth;
    … …  
    107109
    108110typedef struct {
    109   int dx, dy, ascent;
     111  int dx;
     112  int dy;
     113  float dXps;
     114  int ascent;
    110115  unsigned char *bits;
    111116} RotFont;
    … …  
    231236void PSDumpRotSegment PROTO((FILE *f, char *segment, int *Nseg));
    232237void PSSetFont PROTO((FILE *f, char *name, int size));
     238int PSRotStrlen PROTO((char *c));
    233239
    234240/* bDrawFuncs.c */

  • trunk/Ohana/src/libkapa/rotfont

    • Property svn:ignore

      •  

        old new  
        11fixfont
         2fontsize.ps
         3courier.12.psx
         4courier.14.psx
         5courier.18.psx
         6courier.24.psx
         7courier.8.psx
         8helvetica.12.psx
         9helvetica.14.psx
         10helvetica.18.psx
         11helvetica.24.psx
         12helvetica.8.psx
         13symbol.12.psx
         14symbol.14.psx
         15symbol.18.psx
         16symbol.24.psx
         17symbol.8.psx
         18times.12.psx
         19times.14.psx
         20times.18.psx
         21times.24.psx
         22times.8.psx
         23courier12.h
         24courier14.h
         25courier18.h
         26courier24.h
         27courier8.h
         28helvetica12.h
         29helvetica14.h
         30helvetica18.h
         31helvetica24.h
         32helvetica8.h
         33symbol12.h
         34symbol14.h
         35symbol18.h
         36symbol24.h
         37symbol8.h
         38times12.h
         39times14.h
         40times18.h
         41times24.h
         42times8.h

  • trunk/Ohana/src/libkapa/rotfont/fixfont.c

    r5854 r38986  
    11# include <stdio.h>
    22# include <math.h>
     3# include <stdlib.h>
     4# include <string.h>
    35# define TRUE 1
    46# define FALSE 0
    … …  
    2426
    2527typedef struct {
    26   int dx, dy, ascent, Nb;
     28  int dx;
     29  int dy;
     30  float dXps;
     31  int ascent;
     32  int Nb;
    2733  unsigned char *bits;
    2834  char name[64];
    … …  
    3238int scan_line (FILE *f, char *line);
    3339
    34 main (int argc, char **argv) {
     40int main (int argc, char **argv) {
    3541
    3642  int BitMap, Nvalue, code;
    … …  
    4349  FILE *f;
    4450
    45   if (argc != 3) {
    46     fprintf (stderr, "USAGE: fixfont (file.bdf) (name)\n");
     51  if (argc != 4) {
     52    fprintf (stderr, "USAGE: fixfont (file.bdf) (file.psx) (name)\n");
    4753    exit (0);
    4854  }
    4955
    50   f = fopen (argv[1], "r");
     56  char *bdfname = argv[1];
     57  char *psxname = argv[2];
     58  char *fontname = argv[3];
     59
     60  // read in the PS sizes first
     61  f = fopen (psxname, "r");
    5162  if (f == (FILE *) NULL) {
    52     fprintf (stderr, "failed to open file %s\n", argv[1]);
     63    fprintf (stderr, "failed to open file %s\n", psxname);
     64    exit (0);
     65  }
     66
     67  while (scan_line (f, buffer) != EOF) {
     68    int N;
     69    float dXps;
     70    int Nread = sscanf (buffer, "%d %f", &N, &dXps);
     71    if (Nread != 2) continue;
     72    if (N < 1) continue;
     73    if (N > 255) continue;
     74    font[N].dXps = dXps;
     75  }
     76  fclose (f);
     77
     78  f = fopen (bdfname, "r");
     79  if (f == (FILE *) NULL) {
     80    fprintf (stderr, "failed to open file %s\n", bdfname);
    5381    exit (0);
    5482  }
    … …  
    112140      strcpy (font[i].name, "blank");
    113141    }
    114     fprintf (stdout, "static unsigned char %s_%d_bits[] = {", argv[2], i);
     142    fprintf (stdout, "static unsigned char %s_%d_bits[] = {", fontname, i);
    115143    for (j = 0; j < font[i].Nb; j++) {
    116144      if (!(j % 12)) fprintf (stdout, "\n");
    … …  
    121149  }
    122150 
    123   fprintf (stdout, "static RotFont %sfont[] = {\n", argv[2]);
     151  fprintf (stdout, "static RotFont %sfont[] = {\n", fontname);
    124152  for (i = 0; i < 255; i++) {
    125     fprintf (stdout, "{%d, %d, %d, %s_%d_bits},\n",
    126              font[i].dx, font[i].dy, font[i].ascent, argv[2], i);
    127   }
    128   fprintf (stdout, "{%d, %d, %d, %s_%d_bits}};\n",
    129            font[i].dx, font[i].dy, font[i].ascent, argv[2], i);
     153    fprintf (stdout, "{%3d, %3d, %5.2f, %3d, %s_%d_bits},\n",
     154             font[i].dx, font[i].dy, font[i].dXps, font[i].ascent, fontname, i);
     155  }
     156  fprintf (stdout, "{%3d, %3d, %5.2f, %3d, %s_%d_bits}};\n",
     157           font[i].dx, font[i].dy, font[i].dXps, font[i].ascent, fontname, i);
    130158
    131159     
     160  exit (0);
    132161}
    133162
    … …  
    178207
    179208}
    180 

  • trunk/Ohana/src/libkapa/src/DrawRotString.c

    r34088 r38986  
    2222    return (TRUE);
    2323}
     24
     25/* position can be one of 9 values center the text in the following way
     26   0 1 2
     27   3 4 5
     28   6 7 8
     29
     30   e.g., 4 has the center of the string at the x,y position
     31         0 has the lower-right corner at the position (left & up justified)
     32*/
    2433
    2534int DrawRotText (int x, int y, char *string, int pos, double angle) {

  • trunk/Ohana/src/libkapa/src/KapaWindow.c

    r37807 r38986  
    161161                  data[0].labelPadYm, data[0].labelPadYp);
    162162
     163  KiiSendMessage (fd, "%lf %lf %lf %lf",
     164                  data[0].fLabelRangeXm, data[0].fLabelRangeXp,
     165                  data[0].fLabelRangeYm, data[0].fLabelRangeYp);
     166
     167  KiiSendMessage (fd, "%lf %lf %lf %lf",
     168                  data[0].fMinorXm, data[0].fMinorXp,
     169                  data[0].fMinorYm, data[0].fMinorYp);
     170
    163171  KiiSendMessage (fd, "%g %g %g %g ",
    164172                  data[0].coords.pc1_1, data[0].coords.pc2_2,
    … …  
    203211                  &data[0].labelPadXm, &data[0].labelPadXp,
    204212                  &data[0].labelPadYm, &data[0].labelPadYp);
     213
     214  KiiScanMessage (fd, "%lf %lf %lf %lf",
     215                  &data[0].fLabelRangeXm, &data[0].fLabelRangeXp,
     216                  &data[0].fLabelRangeYm, &data[0].fLabelRangeYp);
     217
     218  KiiScanMessage (fd, "%lf %lf %lf %lf",
     219                  &data[0].fMinorXm, &data[0].fMinorXp,
     220                  &data[0].fMinorYm, &data[0].fMinorYp);
    205221
    206222  KiiScanMessage (fd, "%f %f %f %f",

  • trunk/Ohana/src/libkapa/src/PSRotFont.c

    r32695 r38986  
    99  int i, N, code, protect;
    1010  int dX, dY, Xoff, Yoff, X, Y, Nseg, NSEG, YoffBase;
    11   double cs, sn, fscale, currentscale;
     11  double cs, sn, currentscale;
    1212  int basesize, currentsize;
    1313  RotFont *currentfont;
    … …  
    2323 
    2424  /* compute string length */
    25   /* PS fonts are somewhat different scales from bitmap font equivalents */
    26   fscale = 1.0;
    27   if (!strcmp (currentname, "times")) fscale = 1.07;
    28   if (!strcmp (currentname, "courier")) fscale = 1.5;
    29   if (!strcmp (currentname, "helvetica")) fscale = 0.9;
    30   if (!strcmp (currentname, "symbol")) fscale = 1.2;
    31   dX = fscale*RotStrlen (string);
     25  dX = PSRotStrlen (string);
    3226  dY = currentfont[65].ascent;
    3327 
    … …  
    201195}
    202196
     197# define NROT 256
     198int PSRotStrlen (char *c) {
     199
     200  int i, N, dX, code;
     201  double currentscale, scale;
     202
     203  RotFont *currentfont = GetRotFontData (&currentscale);
     204  scale = currentscale;
     205
     206  /* find string length */
     207  dX = 0;
     208
     209  code = FALSE;
     210  for (i = 0; i < strlen (c); i++) {
     211    N = (int)(c[i]);
     212    /* skip non-printing characters */
     213    if ((N < 0) || (N >= NROT)) continue;
     214
     215    /* check for special characters */
     216    if (!code) {
     217      if (N == 94) { /* super-script */
     218        scale *= 0.8;
     219        continue;
     220      }
     221      if (N == 95) { /* sub-script */
     222        scale *= 0.8;
     223        continue;
     224      }
     225      if (N == 124) { /* normal-script */
     226        scale = currentscale;
     227        continue;
     228      }
     229      if (N == 92) { /* backslash */
     230        code = TRUE;
     231        continue;
     232      }
     233      if (N == 38) { /* font-code */
     234        i++;
     235        continue;
     236      }
     237    }
     238    code = FALSE;
     239    dX += scale*currentfont[N].dXps + 1;
     240  }
     241  return (dX);
     242}
    203243
    204244

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

    r38553 r38986  
    5050    PTR = (TYPE *) ohana_malloc (__FILE__, __LINE__, __func__, (SIZE), sizeof(TYPE)); \
    5151  }
     52
     53# define ALLOCATE_PTR(PTR,TYPE,SIZE) \
     54  TYPE *PTR = (TYPE *) ohana_malloc (__FILE__, __LINE__, __func__, (SIZE), sizeof(TYPE));
    5255
    5356# define ALLOCATE_ZERO(PTR,TYPE,SIZE) { \
    … …  
    107110# endif /* OHANA_MEMORY */
    108111
     112void  ohana_memdump_file (FILE *f, int mode);
     113
    109114# endif /* OHANA_ALLOCATE */

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

    r33963 r38986  
    6767void dsort (double *value, int N);
    6868void fsort (float *value, int N);
     69void isort (int *value, int N);
     70
     71void dsortpair (double *X, double *Y, int N);
    6972void fsortpair (float *X, float *Y, int N);
    70 void dsortpair (double *X, double *Y, int N);
    7173void isortpair (int *X, int *Y, int N);
     74
    7275void llsortpair (off_t *X, off_t *Y, off_t N);
     76
     77void dsortthree (double *X, double *Y, double *Z, int N);
    7378void fsortthree (float *X, float *Y, float *Z, int N);
    74 void dsortthree (double *X, double *Y, double *Z, int N);
     79
     80void dsortfour (double *X, double *Y, double *Z, double *W, int N);
    7581void fsortfour (float *X, float *Y, float *Z, float *W, int N);
    76 void dsortfour (double *X, double *Y, double *Z, double *W, int N);
     82void isortfour (int *X, int *Y, int *Z, int *W, int N);
    7783
    7884#endif

  • trunk/Ohana/src/libohana/src/ohana_allocate.c

    r38553 r38986  
    265265}
    266266
    267 int ohana_memcheck_func (int allmemory) {
     267int ohana_memcheck_func (int VERBOSE) {
    268268
    269269  if (!lastBlock) {
    270     fprintf (stderr, "no memory allocated\n");
     270    if (VERBOSE) fprintf (stderr, "no memory allocated\n");
    271271  }
    272272
    … …  
    308308    thisBlock = thisBlock->prevBlock;
    309309  }
    310   fprintf (stderr, "%zd memory blocks allocated (%zd bytes total), %zd good, %zd bad\n", Ntotal, Nbytes, Ngood, Nbad);
     310
     311  if (Ntotal || VERBOSE) {
     312    fprintf (stderr, "%zd memory blocks allocated (%zd bytes total), %zd good, %zd bad\n", Ntotal, Nbytes, Ngood, Nbad);
     313  }
     314
    311315  if (Nbad) status = FALSE;
    312316
    … …  
    356360    thisBlock = thisBlock->prevBlock;
    357361  }
    358   fprintf (stderr, "%zd memory blocks freed     (%zd bytes total), %zd good, %zd bad\n", Ntotal_free, Nbytes_free, Ngood_free, Nbad_free);
     362
     363  if (Ntotal_free || VERBOSE) {
     364    fprintf (stderr, "%zd memory blocks freed     (%zd bytes total), %zd good, %zd bad\n", Ntotal_free, Nbytes_free, Ngood_free, Nbad_free);
     365  }
     366
    359367  if (Nbad_free) status = FALSE;
    360368
    … …  
    405413    thisBlock = thisBlock->prevBlock;
    406414  }
    407   fprintf (stderr, "%zd memory blocks dropped   (%zd bytes total), %zd good, %zd bad\n", Ntotal_drop, Nbytes_drop, Ngood_drop, Nbad_drop);
     415
     416  if (Ntotal_drop || VERBOSE) {
     417    fprintf (stderr, "%zd memory blocks dropped   (%zd bytes total), %zd good, %zd bad\n", Ntotal_drop, Nbytes_drop, Ngood_drop, Nbad_drop);
     418  }
     419
    408420  if (Nbad_drop) status = FALSE;
    409421# endif
    … …  
    412424}
    413425
    414 void ohana_memdump_func (int allmemory) {
     426void ohana_memdump_file (FILE *f, int VERBOSE) {
    415427
    416428  if (!lastBlock) {
    417     fprintf (stderr, "no memory allocated\n");
     429    if (VERBOSE) fprintf (f, "no memory allocated\n");
    418430    return;
    419431  }
    … …  
    424436  size_t Nbytes = 0;
    425437
    426   fprintf (stderr, " entry | bytes | cumulative | STATUS | file | line | function\n");
     438  fprintf (f, " entry | bytes | cumulative | STATUS | file | line | function\n");
    427439
    428440  while (thisBlock) {
    … …  
    444456    if (Ntotal < 100) {
    445457      if (good) {
    446         fprintf (stderr, "  %zd  %zd  %zd  GOOD  %s %d, func: %s\n", Ntotal, thisBlock->size, Nbytes, thisBlock->file, thisBlock->line, thisBlock->func);
     458        fprintf (f, "  %zd  %zd  %zd  GOOD  %s %d, func: %s\n", Ntotal, thisBlock->size, Nbytes, thisBlock->file, thisBlock->line, thisBlock->func);
    447459      } else {
    448         fprintf (stderr, "  %zd  %zd  %zd  BAD   %s %d, func: %s\n", Ntotal, thisBlock->size, Nbytes, thisBlock->file, thisBlock->line, thisBlock->func);
     460        fprintf (f, "  %zd  %zd  %zd  BAD   %s %d, func: %s\n", Ntotal, thisBlock->size, Nbytes, thisBlock->file, thisBlock->line, thisBlock->func);
    449461      }
    450462    }
    … …  
    452464    thisBlock = thisBlock->prevBlock;
    453465  }
    454   fprintf (stderr, "%zd memory blocks allocated (%zd bytes total)\n", Ntotal, Nbytes);
    455 
     466
     467  if (Ntotal || VERBOSE) {
     468    fprintf (f, "%zd memory blocks allocated (%zd bytes total)\n", Ntotal, Nbytes);
     469  }
     470
     471  return;
     472}
     473
     474void ohana_memdump_func (int VERBOSE) {
     475  ohana_memdump_file (stderr, VERBOSE);
    456476  return;
    457477}

  • trunk/Ohana/src/libohana/src/sorts.c

    r33963 r38986  
    2727}
    2828
    29 void fsortpair (float *X, float *Y, int N) {
     29void isort (int *value, int N) {
    3030
    31 # define SWAPFUNC(A,B){ float tmp; \
     31# define SWAPFUNC(A,B){ int tmp = value[A]; value[A] = value[B]; value[B] = tmp; }
     32# define COMPARE(A,B)(value[A] < value[B])
     33
     34  OHANA_SORT (N, COMPARE, SWAPFUNC);
     35
     36# undef SWAPFUNC
     37# undef COMPARE
     38
     39}
     40
     41void dsortpair (double *X, double *Y, int N) {
     42
     43# define SWAPFUNC(A,B){ double tmp; \
    3244  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
    3345  tmp = Y[A]; Y[A] = Y[B]; Y[B] = tmp; \
    … …  
    4254}
    4355
    44 void dsortpair (double *X, double *Y, int N) {
     56void fsortpair (float *X, float *Y, int N) {
    4557
    46 # define SWAPFUNC(A,B){ double tmp; \
     58# define SWAPFUNC(A,B){ float tmp; \
    4759  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
    4860  tmp = Y[A]; Y[A] = Y[B]; Y[B] = tmp; \
    … …  
    89101}
    90102
     103void dsortthree (double *X, double *Y, double *Z, int N) {
     104
     105# define SWAPFUNC(A,B){ double tmp; \
     106  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
     107  tmp = Y[A]; Y[A] = Y[B]; Y[B] = tmp; \
     108  tmp = Z[A]; Z[A] = Z[B]; Z[B] = tmp; \
     109}
     110# define COMPARE(A,B)(X[A] < X[B])
     111
     112  OHANA_SORT (N, COMPARE, SWAPFUNC);
     113
     114# undef SWAPFUNC
     115# undef COMPARE
     116
     117}
     118
    91119void fsortthree (float *X, float *Y, float *Z, int N) {
    92120
    … …  
    105133}
    106134
    107 void dsortthree (double *X, double *Y, double *Z, int N) {
     135void dsortfour (double *X, double *Y, double *Z, double *W, int N) {
    108136
    109137# define SWAPFUNC(A,B){ double tmp; \
    … …  
    111139  tmp = Y[A]; Y[A] = Y[B]; Y[B] = tmp; \
    112140  tmp = Z[A]; Z[A] = Z[B]; Z[B] = tmp; \
     141  tmp = W[A]; W[A] = W[B]; W[B] = tmp; \
    113142}
    114143# define COMPARE(A,B)(X[A] < X[B])
    … …  
    138167}
    139168
    140 void dsortfour (double *X, double *Y, double *Z, double *W, int N) {
     169void isortfour (int *X, int *Y, int *Z, int *W, int N) {
    141170
    142 # define SWAPFUNC(A,B){ double tmp; \
     171# define SWAPFUNC(A,B){ int tmp; \
    143172  tmp = X[A]; X[A] = X[B]; X[B] = tmp; \
    144173  tmp = Y[A]; Y[A] = Y[B]; Y[B] = tmp; \
    … …  
    154183
    155184}
     185

  • trunk/Ohana/src/markrock/src/markrock.c

    r38471 r38986  
    6060
    6161  /* rocks2 = find_slow_rocks (&catalog, &catstats, &Nrocks2);  */
    62   dvo_catalog_save (&catalog, VERBOSE);
    63   dvo_catalog_unlock (&catalog);
     62  SetProtect (TRUE);
     63  if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     64  if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     65  SetProtect (FALSE);
     66   
    6467  dvo_catalog_free (&catalog);
    6568

  • trunk/Ohana/src/markstar/src/markstar.c

    r38471 r38986  
    6868  /* find_ghosts (&catalog, &catstats, argv[1], image, Nimage); */
    6969
    70   dvo_catalog_save (&catalog, VERBOSE);
    71   dvo_catalog_unlock (&catalog);
     70  SetProtect (TRUE);
     71  if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     72  if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     73  SetProtect (FALSE);
     74
    7275  dvo_catalog_free (&catalog);
    7376

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

    r37807 r38986  
    77
    88typedef struct {
     9  double *X;
     10  double *Y;
     11  double *t;
     12  double *pX;
     13  double *pY;
     14  double *dX;
     15  double *dY;
     16  int *index;
     17  int Npts;
     18} PlxFitData;
     19
     20typedef struct {
    921  double Ro, dRo;
    1022  double Do, dDo;
    … …  
    1729  double chisq;
    1830  int Nfit;
     31  int getChisq;
    1932} PlxFit;
     33
     34int VectorRobustStats (Vector *vector, double *median, double *sigma);
     35double VectorFractionInterpolate (double *values, float fraction, int Npts);
     36
     37int PlxSetMeanEpoch (double *R, double *D, double *T, double *Rmean, double *Dmean, double *Tmean, int *mask, int Ntotal);
     38int PlxSetEpochPosition (PlxFitData *fitdata, double *R, double *D, double *dR, double *dD, double *T, int *mask, int Ntotal, Coords *coords, double Tmean);
     39int PlxOutlierClip (PlxFitData *fitdata, int *mask, int Noutlier, float dPsigMax, Vector *dPvec, int VERBOSE);
     40
     41int PlxFitDataAlloc (PlxFitData *data, int N);
     42void PlxFitDataFree (PlxFitData *data);
     43int PlxBootstrapResample (PlxFitData *src, PlxFitData *tgt);
    2044
    2145int FitPMandPar (PlxFit *fit, double *X, double *dX, double *Y, double *dY, double *T, double *pR, double *pD, int Npts, int VERBOSE);
    … …  
    4771  }
    4872
     73  int Noutlier = 0;
     74  float dPsigMax = FLT_MAX;
     75  if ((N = get_argument (argc, argv, "-outlier-tests"))) {
     76    remove_argument (N, &argc, argv);
     77    Noutlier = atoi(argv[N]);
     78    remove_argument (N, &argc, argv);
     79    dPsigMax = atof(argv[N]);
     80    remove_argument (N, &argc, argv);
     81  }
     82
     83  int Nresample = 0;
     84  if ((N = get_argument (argc, argv, "-bootstrap-resample"))) {
     85    remove_argument (N, &argc, argv);
     86    Nresample = atoi(argv[N]);
     87    remove_argument (N, &argc, argv);
     88  }
     89
     90  Vector *dPvec = NULL;
     91  if ((N = get_argument (argc, argv, "-dPsig"))) {
     92    if (!Noutlier) { gprint (GP_ERR, "-dPsig requires -outlier-tests to be non-zero\n"); return FALSE; }
     93    remove_argument (N, &argc, argv);
     94    if (!(dPvec = SelectVector (argv[N], ANYVECTOR, TRUE))) return FALSE;
     95    remove_argument (N, &argc, argv);
     96  }
     97
    4998  if (argc != 6) {
    50     gprint (GP_ERR, "USAGE: fitplx (ra) (dR) (dec) (dD) (mjd) [-mask mask]\n");
    51     // what about the errors?
     99    gprint (GP_ERR, "USAGE: fitplx (ra) (dR) (dec) (dD) (mjd) [-mask mask] [-v] [-vv]\n");
     100    gprint (GP_ERR, "  -outlier-tests Nsamples dPsigMax : run Nsample bootstrap-resamples to define the path deviations and reject based on dPsigMax\n");
     101    gprint (GP_ERR, "  -dPsig vec : save path deviations in vec\n");
    52102    return (FALSE);
    53103  }
    … …  
    77127  }
    78128
    79   N = tvec->Nelements; // XXX check other lengths
    80 
    81   // find mean values to remove
    82   double Npts = 0;
    83   double Tmean = 0;
    84   double Rmean = 0;
    85   double Dmean = 0;
    86   double Tmin = +1000000;
    87   double Tmax = -1000000;
    88   for (i = 0; i < N; i++) {
    89     if (mask && !mask[i]) continue;
    90     Rmean += R[i];
    91     Dmean += D[i];
    92     Tmean += T[i];
    93     Tmin = MIN(Tmin, T[i]);
    94     Tmax = MAX(Tmax, T[i]);
    95     Npts += 1.0;
    96   }
    97   Rmean /= Npts;
    98   Dmean /= Npts;
    99   Tmean /= Npts;
    100 
    101   float Trange = Tmax - Tmin;
    102   // fprintf (stderr, "R,D : %f,%f, T: %f, Trange: %f, Tmin: %f, Tmax: %f\n", Rmean, Dmean, Tmean, Trange, Tmin, Tmax);
     129  // Ntotal : all points supplied by user
     130  // Nsubset : unmasked points
     131  int Ntotal = tvec->Nelements; // XXX check other lengths
     132  if (dPvec) ResetVector (dPvec, OPIHI_FLT, Ntotal);
     133
     134  double Rmean, Dmean, Tmean;
     135  PlxSetMeanEpoch (R, D, T, &Rmean, &Dmean, &Tmean, mask, Ntotal);
    103136
    104137  /* project coordinates to a plane centered on the object with units of arcsec */
    … …  
    109142  coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
    110143
    111   double *X, *Y, *t, *pX, *pY, *dX, *dY;
    112   ALLOCATE (X, double, N);
    113   ALLOCATE (Y, double, N);
    114   ALLOCATE (dX, double, N);
    115   ALLOCATE (dY, double, N);
    116   ALLOCATE (t, double, N);
    117   ALLOCATE (pX, double, N);
    118   ALLOCATE (pY, double, N);
    119 
    120   float pXmin = +2.0;
    121   float pXmax = -2.0;
    122   float pYmin = +2.0;
    123   float pYmax = -2.0;
    124 
    125   int n = 0;
    126   for (i = 0; i < N; i++) {
    127     if (mask && !mask[i]) continue;
    128     RD_to_XY (&X[n], &Y[n], R[i], D[i], &coords);
    129     dX[n] = dR[i];
    130     dY[n] = dD[i];
    131     t[n] = (T[i] - Tmean) / 365.25;
    132     ParFactor (&pX[n], &pY[n], R[i], D[i], T[i]);
    133     pXmin = MIN (pXmin, pX[n]);
    134     pXmax = MAX (pXmax, pX[n]);
    135     pYmin = MIN (pYmin, pY[n]);
    136     pYmax = MAX (pYmax, pY[n]);
    137     n++;
    138   }
    139   float dXRange = pXmax - pXmin;
    140   float dYRange = pYmax - pYmin;
    141   float parRange = hypot (dXRange, dYRange);
    142        
    143   // fprintf (stderr, "par factor range: %f\n", parRange);
    144 
    145   PlxFit fit;
    146   if (!FitPMandPar (&fit, X, dX, Y, dY, t, pX, pY, n, VERBOSE)) {
     144  PlxFitData fitdata;
     145  PlxFitDataAlloc (&fitdata, Ntotal);
     146  PlxSetEpochPosition (&fitdata, R, D, dR, dD, T, mask, Ntotal, &coords, Tmean);
     147
     148  PlxFit fit; memset (&fit, 0, sizeof(PlxFit));
     149
     150  // determine dPsig for detections based on Noutlier attempts
     151  if (Noutlier) {
     152    int clipRetry = TRUE;
     153    for (i = 0; clipRetry && (i < 3); i++) {
     154      clipRetry = !PlxOutlierClip (&fitdata, mask, Noutlier, dPsigMax, dPvec, VERBOSE);
     155
     156      // using the new mask values, reset fitdata
     157      PlxSetMeanEpoch (R, D, T, &Rmean, &Dmean, &Tmean, mask, Ntotal);
     158      PlxSetEpochPosition (&fitdata, R, D, dR, dD, T, mask, Ntotal, &coords, Tmean);
     159      if (VERBOSE) fprintf (stderr, "keep %d of %d\n", fitdata.Npts, Ntotal);
     160    }
     161  }
     162
     163  for (i = 0; (VERBOSE == 2) && (i < fitdata.Npts); i++) {
     164    int n = fitdata.index[i];
     165    int maskValue = mask ? mask[n] : 0;
     166    fprintf (stderr, "%f %f : %f %d : %f %f %f\n", R[n], D[n], T[n], maskValue, fitdata.t[i], fitdata.X[i], fitdata.Y[i]);
     167  }
     168
     169  fit.getChisq = TRUE;
     170  if (!FitPMandPar (&fit,
     171                    fitdata.X, fitdata.dX,
     172                    fitdata.Y, fitdata.dY,
     173                    fitdata.t, fitdata.pX, fitdata.pY, fitdata.Npts, VERBOSE)) {
    147174    return FALSE;
    148175  }
     176
     177  if (Nresample){
     178    PlxFitData sample;
     179    PlxFitDataAlloc (&sample, fitdata.Npts);
     180
     181    PlxFit *testfit = NULL;
     182    ALLOCATE (testfit, PlxFit, Nresample);
     183
     184    int Ngood = 0;
     185    for (i = 0; i < Nresample; i++) {
     186      PlxBootstrapResample (&fitdata, &sample);
     187     
     188      if (i % 100000 == 99999) fprintf (stderr, ".");
     189
     190      // fit the sample
     191      testfit[Ngood].getChisq = FALSE;
     192      if (!FitPMandPar (&testfit[Ngood],
     193                        sample.X, sample.dX,
     194                        sample.Y, sample.dY, sample.t,
     195                        sample.pX, sample.pY, sample.Npts, VERBOSE)) continue;
     196      Ngood ++;
     197    }
     198
     199    Vector *pvec, *uRvec, *uDvec, *Rvec, *Dvec;
     200
     201    // save the Nresample histograms
     202    if ((pvec  = SelectVector ("plxVector", ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", "plxVector");
     203    if ((uRvec = SelectVector ("uRVector",  ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", "uDVector");
     204    if ((uDvec = SelectVector ("uDVector",  ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", "uRVector");
     205    if ((Rvec  = SelectVector ("RoVector",  ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", "RoVector");
     206    if ((Dvec  = SelectVector ("DoVector",  ANYVECTOR, TRUE)) == NULL) ESCAPE ("missing vector %s\n", "DoVector");
     207   
     208    ResetVector ( pvec, OPIHI_FLT, Ngood);
     209    ResetVector (uRvec, OPIHI_FLT, Ngood);
     210    ResetVector (uDvec, OPIHI_FLT, Ngood);
     211    ResetVector ( Rvec, OPIHI_FLT, Ngood);
     212    ResetVector ( Dvec, OPIHI_FLT, Ngood);
     213   
     214    for (i = 0; i < Ngood; i++) {
     215      pvec->elements.Flt[i]  = testfit[i].p;
     216      uRvec->elements.Flt[i] = testfit[i].uR;
     217      uDvec->elements.Flt[i] = testfit[i].uD;
     218      Rvec->elements.Flt[i]  = testfit[i].Ro;
     219      Dvec->elements.Flt[i]  = testfit[i].Do;
     220    }
     221
     222    // now calculate median and sigma for each vector
     223    VectorRobustStats (pvec,  &fit.p,  &fit.dp);
     224    VectorRobustStats (uRvec, &fit.uR, &fit.duR);
     225    VectorRobustStats (uDvec, &fit.uD, &fit.duD);
     226    VectorRobustStats (Rvec,  &fit.Ro, &fit.dRo);
     227    VectorRobustStats (Dvec,  &fit.Do, &fit.dDo);
     228  }
     229
     230  // fprintf (stderr, "%f +/- %f | %f %f\n", fit.p, fit.dp, fit.uR, fit.uD);
     231
     232/*
     233  FILE *f = fopen ("test.pf.dat", "w");
     234  for (i = 0; i < Ntotal; i++) {
     235    double Xf = fit.Ro + fit.uR*fitdata.t[i] + fit.p*fitdata.pX[i];
     236    double Yf = fit.Do + fit.uD*fitdata.t[i] + fit.p*fitdata.pY[i];
     237    fprintf (f, "%f : %f %f : %f %f : %f : %f %f : %f %f\n", T[i], R[i], D[i], Xf, Yf, fitdata.t[i], fitdata.X[i], fitdata.Y[i], fitdata.pX[i], fitdata.pY[i]);
     238  }
     239  fclose (f);
     240*/
    149241
    150242  // fprintf (stderr, "Roff, Doff: %f, %f; dRo, dDo: %f, %f\n", fit.Ro, fit.Do, fit.dRo, fit.dDo);
    … …  
    152244  XY_to_RD (&Rmean, &Dmean, fit.Ro, fit.Do, &coords);
    153245  if (VERBOSE) {
    154     fprintf (stderr, "Ro, Do: %f, %f +/- %f, %f\n", Rmean, Dmean, fit.dRo, fit.dDo);
     246    fprintf (stderr, "Ro, Do: %f, %f +/- %f, %f (%f, %f)\n", Rmean, Dmean, fit.dRo, fit.dDo, fit.Ro, fit.Do);
    155247    fprintf (stderr, "uR, uD: %f, %f; duR, duD: %f, %f\n", fit.uR, fit.uD, fit.duR, fit.duD);
    156248    fprintf (stderr, "par: %f +/- %f\n", fit.p, fit.dp);
    … …  
    164256  set_variable ("uR",   fit.uR);
    165257  set_variable ("uD",   fit.uD);
    166   set_variable ("duR",   fit.duR);
    167   set_variable ("duD",   fit.duD);
     258  set_variable ("duR",  fit.duR);
     259  set_variable ("duD",  fit.duD);
    168260  set_variable ("plx",  fit.p);
    169261  set_variable ("dplx", fit.dp);
    170262 
    171263  set_variable ("Tmean",  Tmean);
    172   set_variable ("Trange", Trange);
    173   set_variable ("Prange", parRange);
    174264
    175265  set_variable ("chisq", fit.chisq);
    … …  
    293383  fit[0].dp  = sqrt(A[4][4]);
    294384 
    295   // add up the chi square for the fit
    296   chisq = 0.0;
    297   for (i = 0; i < Npts; i++) {
    298     Xf = fit[0].Ro + fit[0].uR*T[i] + fit[0].p*pR[i];
    299     Yf = fit[0].Do + fit[0].uD*T[i] + fit[0].p*pD[i];
    300     wx = (fabs(dX[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dX[i]);
    301     wy = (fabs(dY[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dY[i]);
    302     chisq += SQ(X[i] - Xf) * wx;
    303     chisq += SQ(Y[i] - Yf) * wy;
    304     // if (VERBOSE) fprintf (stderr, "chisq contrib : %f %f : %f %f : %f %f : %f %f : %f\n", Xf, Yf, X[i] - Xf, Y[i] - Yf, dX[i], dY[i], (X[i] - Xf) / dX[i], (Y[i] - Yf) / dY[i], chisq);
    305   }
     385  // (optionally) add up the chi square for the fit
     386  if (fit->getChisq) {
     387    chisq = 0.0;
     388    for (i = 0; i < Npts; i++) {
     389      Xf = fit[0].Ro + fit[0].uR*T[i] + fit[0].p*pR[i];
     390      Yf = fit[0].Do + fit[0].uD*T[i] + fit[0].p*pD[i];
     391      wx = (fabs(dX[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dX[i]);
     392      wy = (fabs(dY[i]) < 0.0001) ? 1.0 : 1.0 / SQ(dY[i]);
     393      chisq += SQ(X[i] - Xf) * wx;
     394      chisq += SQ(Y[i] - Yf) * wy;
     395      // if (VERBOSE) fprintf (stderr, "chisq contrib : %f %f : %f %f : %f %f : %f %f : %f\n", Xf, Yf, X[i] - Xf, Y[i] - Yf, dX[i], dY[i], (X[i] - Xf) / dX[i], (Y[i] - Yf) / dY[i], chisq);
     396    }
     397    // the reduced chisq is divided by (Ndof = 2*Npts - 5)
     398    fit[0].chisq = chisq / (2.0*Npts - 5.0);
     399  }
     400 
    306401  fit[0].Nfit = Npts;
    307 
    308   // the reduced chisq is divided by (Ndof = 2*Npts - 5)
    309   fit[0].chisq = chisq / (2.0*Npts - 5.0);
    310402  return (TRUE);
    311403}
    … …  
    349441  return TRUE;
    350442}
     443
     444// allocate arrays but not the container
     445int PlxFitDataAlloc (PlxFitData *data, int N) {
     446
     447  data->Npts = N;
     448  ALLOCATE (data->X, double, N);
     449  ALLOCATE (data->Y, double, N);
     450  ALLOCATE (data->dX, double, N);
     451  ALLOCATE (data->dY, double, N);
     452  ALLOCATE (data->t, double, N);
     453  ALLOCATE (data->pX, double, N);
     454  ALLOCATE (data->pY, double, N);
     455  ALLOCATE (data->index, int, N);
     456  return TRUE;
     457}
     458
     459void PlxFitDataFree (PlxFitData *data) {
     460  FREE (data->X);
     461  FREE (data->Y);
     462  FREE (data->dX);
     463  FREE (data->dY);
     464  FREE (data->t);
     465  FREE (data->pX);
     466  FREE (data->pY);
     467  FREE (data->index);
     468}
     469
     470int PlxBootstrapResample (PlxFitData *src, PlxFitData *tgt) {
     471  int i;
     472  tgt->Npts = src->Npts;
     473  for (i = 0; i < src->Npts; i++) {
     474    int N = tgt->Npts * drand48();
     475    // int N = i;
     476    tgt->X [i] = src->X [N];
     477    tgt->Y [i] = src->Y [N];
     478    tgt->dX[i] = src->dX[N];
     479    tgt->dY[i] = src->dY[N];
     480    tgt->t [i] = src->t [N];
     481    tgt->pX[i] = src->pX[N];
     482    tgt->pY[i] = src->pY[N];
     483  }
     484  return TRUE;
     485}
     486
     487int PlxSetMeanEpoch (double *R, double *D, double *T, double *Rmean, double *Dmean, double *Tmean, int *mask, int Ntotal) {
     488
     489  int i;
     490
     491  // find mean values to remove
     492  double Nmean = 0;
     493  *Tmean = 0;
     494  *Rmean = 0;
     495  *Dmean = 0;
     496  double Tmin = +1000000;
     497  double Tmax = -1000000;
     498  for (i = 0; i < Ntotal; i++) {
     499    if (mask && !mask[i]) continue;
     500    *Rmean += R[i];
     501    *Dmean += D[i];
     502    *Tmean += T[i];
     503    Tmin = MIN(Tmin, T[i]);
     504    Tmax = MAX(Tmax, T[i]);
     505    Nmean += 1.0;
     506  }
     507  *Rmean /= Nmean;
     508  *Dmean /= Nmean;
     509  *Tmean /= Nmean;
     510 
     511  double Trange = Tmax - Tmin;
     512
     513  // fprintf (stderr, "R,D : %f,%f, T: %f, Trange: %f, Tmin: %f, Tmax: %f\n", *Rmean, *Dmean, *Tmean, Trange, Tmin, Tmax);
     514
     515  set_variable ("Trange", Trange);
     516  return TRUE;
     517}
     518
     519// generate the fit values (projected X,Y; parallax factors;
     520int PlxSetEpochPosition (PlxFitData *fitdata, double *R, double *D, double *dR, double *dD, double *T, int *mask, int Ntotal, Coords *coords, double Tmean) {
     521
     522  int i;
     523
     524  float pXmin = +2.0;
     525  float pXmax = -2.0;
     526  float pYmin = +2.0;
     527  float pYmax = -2.0;
     528
     529  int Nsubset = 0;
     530  for (i = 0; i < Ntotal; i++) {
     531    if (mask && !mask[i]) continue;
     532    RD_to_XY (&fitdata->X[Nsubset], &fitdata->Y[Nsubset], R[i], D[i], coords);
     533    fitdata->dX[Nsubset] = dR[i];
     534    fitdata->dY[Nsubset] = dD[i];
     535    fitdata->t[Nsubset] = (T[i] - Tmean) / 365.25;
     536    ParFactor (&fitdata->pX[Nsubset], &fitdata->pY[Nsubset], R[i], D[i], T[i]);
     537    pXmin = MIN (pXmin, fitdata->pX[Nsubset]);
     538    pXmax = MAX (pXmax, fitdata->pX[Nsubset]);
     539    pYmin = MIN (pYmin, fitdata->pY[Nsubset]);
     540    pYmax = MAX (pYmax, fitdata->pY[Nsubset]);
     541    fitdata->index[Nsubset] = i;
     542    Nsubset++;
     543  }
     544  fitdata->Npts = Nsubset;
     545  float dXRange = pXmax - pXmin;
     546  float dYRange = pYmax - pYmin;
     547  float parRange = hypot (dXRange, dYRange);
     548
     549  set_variable ("Prange", parRange);
     550  // fprintf (stderr, "par factor range: %f\n", parRange);
     551
     552  return TRUE;
     553}
     554
     555/* Outlier clipping based on bootstrap-resampling tests of the plx path
     556 * generate Noutlier resampled datasets
     557 * fit the Noutlier plx paths
     558 * determine and save the distribution of dXsig and dYsig for each point
     559 * sort the resulting distributions and find dPsig (median point) for each measurement
     560 * find the 90% point of dPsig : if > dPsigMax, only clip the 10% most deviant points
     561 * set the dPvec values if desired
     562 * -- mask is modified, dPvec values are set
     563 * -- fitdata is unchanged
     564 */
     565
     566# define MAX_REJECT 0.1
     567
     568int PlxOutlierClip (PlxFitData *fitdata, int *mask, int Noutlier, float dPsigMax, Vector *dPvec, int VERBOSE) {
     569
     570  int i, n;
     571
     572  PlxFit testfit;
     573  testfit.getChisq = FALSE;
     574
     575  PlxFitData sample;
     576  PlxFitDataAlloc (&sample, fitdata->Npts);
     577
     578  double **dXsig, **dYsig;
     579  ALLOCATE (dXsig, double *, fitdata->Npts);
     580  ALLOCATE (dYsig, double *, fitdata->Npts);
     581  for (i = 0; i < fitdata->Npts; i++) {
     582    ALLOCATE (dXsig[i], double, Noutlier);
     583    ALLOCATE (dYsig[i], double, Noutlier);
     584  }
     585
     586  int Nsamples = 0;
     587  for (n = 0; n < Noutlier; n++) {
     588    // bootstrap resample (fitdata -> sample)
     589    PlxBootstrapResample (fitdata, &sample);
     590     
     591    if (n % 100000 == 99999) fprintf (stderr, ".");
     592
     593    // fit the sample
     594    if (!FitPMandPar (&testfit,
     595                      sample.X, sample.dX,
     596                      sample.Y, sample.dY, sample.t,
     597                      sample.pX, sample.pY, sample.Npts, VERBOSE)) continue;
     598
     599    // fprintf (stderr, "%f +/- %f | %f %f\n", testfit.p, testfit.dp, testfit.uR, testfit.uD);
     600
     601    // find the distances to the path
     602    for (i = 0; i < fitdata->Npts; i++) {
     603      double Xf = testfit.Ro + testfit.uR*fitdata->t[i] + testfit.p*fitdata->pX[i];
     604      double Yf = testfit.Do + testfit.uD*fitdata->t[i] + testfit.p*fitdata->pY[i];
     605      dXsig[i][Nsamples] = fabs(fitdata->X[i] - Xf) / fitdata->dX[i];
     606      dYsig[i][Nsamples] = fabs(fitdata->Y[i] - Yf) / fitdata->dY[i];
     607      // fprintf (stderr, "%f : %f %f : %f %f : %f %f : %f %f %f\n", T[i], Xf, Yf, fitdata->X[i], fitdata->Y[i], fitdata->dX[i], fitdata->dY[i], fitdata->t[i], fitdata->pX[i], fitdata->pY[i]);
     608    }
     609    Nsamples ++;
     610  }
     611
     612  double *dPsig;
     613  ALLOCATE (dPsig, double, fitdata->Npts);
     614   
     615  for (i = 0; i < fitdata->Npts; i++) {
     616    dsort (dXsig[i], Nsamples);
     617    dsort (dYsig[i], Nsamples);
     618
     619    // choose the median values
     620    double dXsigMedian, dYsigMedian;
     621    if (Nsamples % 2) {
     622      int Ncenter = Nsamples / 2;
     623      dXsigMedian = dXsig[i][Ncenter];
     624      dYsigMedian = dYsig[i][Ncenter];
     625    } else {
     626      int Ncenter = Nsamples / 2 - 1;
     627      dXsigMedian = 0.5*(dXsig[i][Ncenter] + dXsig[i][Ncenter + 1]);
     628      dYsigMedian = 0.5*(dYsig[i][Ncenter] + dYsig[i][Ncenter + 1]);
     629    }
     630    // XXX replace with hypotenuse?
     631    dPsig[i] = 0.5*(dXsigMedian + dYsigMedian);
     632    // fprintf (stderr, "%d %10.6f %10.6f %10.6f  %f %f : %f\n", i, R[i], D[i], T[i], dXsig[i][Ncenter], dYsig[i][Ncenter], dPsig[i]);
     633  }
     634
     635  // make a copy of dPsig[] and check if > 10% are > dPsigMax
     636  double *dPsigSort;
     637  ALLOCATE (dPsigSort, double, fitdata->Npts);
     638  for (i = 0; i < fitdata->Npts; i++) {
     639    dPsigSort[i] = dPsig[i];
     640  }
     641  dsort (dPsigSort, fitdata->Npts);
     642  int Nmax = (1.0 - MAX_REJECT)*fitdata->Npts;
     643
     644  int completeClip = TRUE;
     645  if (dPsigSort[Nmax] > dPsigMax) {
     646    if (VERBOSE) fprintf (stderr, "too many outliers: %f at 90\n", dPsigSort[Nmax]);
     647    dPsigMax = dPsigSort[Nmax];
     648    completeClip = FALSE;
     649  }
     650
     651  for (i = 0; i < fitdata->Npts; i++) {
     652    if (dPsig[i] < dPsigMax) continue;
     653    int n = fitdata->index[i];
     654    // fprintf (stderr, "clip %d: %f : %f\n", i, fitdata->t[i], dPsig[i]);
     655    mask[n] = 0; // mask these points
     656  }
     657
     658  // only set dPvec if we have completed the clipping?
     659  if (dPvec) {
     660    for (i = 0; i < dPvec->Nelements; i++) {
     661      dPvec->elements.Flt[i] = NAN;
     662    }
     663    for (i = 0; i < fitdata->Npts; i++) {
     664      int n = fitdata->index[i];
     665      dPvec->elements.Flt[n] = dPsig[i];
     666    }
     667  }
     668
     669  free (dPsig);
     670  free (dPsigSort);
     671 
     672  for (i = 0; i < fitdata->Npts; i++) {
     673    free (dXsig[i]);
     674    free (dYsig[i]);
     675  }
     676  free (dXsig);
     677  free (dYsig);
     678
     679  return completeClip;
     680}
     681
     682int VectorRobustStats (Vector *vector, double *median, double *sigma) {
     683
     684  // warn if vector->Nelements > 1000? 10000?)
     685  // warn if vector is not float
     686
     687  // we need to copy the vector to avoid changing the sort order
     688  double *values = NULL;
     689  ALLOCATE (values, double, vector->Nelements);
     690
     691  int i;
     692  int Npts = 0;
     693  for (i = 0; i < vector->Nelements; i++) {
     694    if (!isfinite(vector->elements.Flt[i])) continue;
     695    values[Npts] = vector->elements.Flt[i];
     696    Npts++;
     697  }
     698
     699  dsort (values, Npts);
     700
     701  if (Npts % 2) {
     702    int Ncenter = Npts / 2;
     703    *median = values[Ncenter];
     704  } else {
     705    int Ncenter = Npts / 2 - 1;
     706    *median = 0.5*(values[Ncenter] + values[Ncenter + 1]);
     707  }
     708
     709  double Slo = VectorFractionInterpolate (values, 0.158655, Npts);
     710  double Shi = VectorFractionInterpolate (values, 0.841345, Npts);
     711
     712  *sigma = (Shi - Slo) / 2.0;
     713
     714  return TRUE;
     715}
     716
     717double VectorFractionInterpolate (double *values, float fraction, int Npts) {
     718
     719  float F = fraction * Npts;
     720  int   N = fraction * Npts;
     721
     722  if (N < 0        ) return NAN;
     723  if (N >= Npts - 2) return NAN;
     724
     725  // interpolate between N,N+1
     726   
     727  double S = (F - N) * (values[N+1] - values[N]) + values[N];
     728  return S;
     729}

  • trunk/Ohana/src/opihi/cmd.basic/date.c

    r27435 r38986  
    33int date (int argc, char **argv) {
    44 
    5   int N, SECONDS, REFTIME;
     5  int N, SECONDS;
     6  double REFTIME;
    67  struct timeval now;
    78  char *tstring = NULL;
    … …  
    1617  }
    1718
    18   REFTIME = 0;
     19  REFTIME = 0.0;
    1920  if ((N = get_argument (argc, argv, "-reftime"))) {
    2021    remove_argument (N, &argc, argv);
    21     REFTIME = atoi (argv[N]);
     22    REFTIME = atof (argv[N]);
    2223    remove_argument (N, &argc, argv);
    2324  }
    … …  
    3738  gettimeofday (&now, NULL);
    3839  if (SECONDS) {
     40    double nowSec = now.tv_sec + 1e-6*now.tv_usec;
    3941    if (varName) {
    40       set_int_variable (varName, now.tv_sec - REFTIME);
     42      set_variable (varName, nowSec - REFTIME);
    4143    } else {
    42       gprint (GP_ERR, "%d\n", (int) now.tv_sec - REFTIME);
     44      gprint (GP_ERR, "%.12g\n", nowSec - REFTIME);
    4345    }
    4446  } else {

  • trunk/Ohana/src/opihi/cmd.data/box.c

    r34749 r38986  
    4848    if (strlen (graphmode.ticks) != 4) { goto usage; }
    4949    for (i = 0; i < strlen (graphmode.ticks); i++) {
    50       if ((graphmode.ticks[i] != '0') && (graphmode.ticks[i] != '1') && (graphmode.ticks[i] != '2')) { goto usage; }
     50      if ((graphmode.ticks[i] != '0') && (graphmode.ticks[i] != '1') && (graphmode.ticks[i] != '2') && (graphmode.ticks[i] != '3')) { goto usage; }
    5151    }
    5252  }
    … …  
    139139    remove_argument (N, &argc, argv);
    140140    graphmode.padYp = atof(argv[N]);
     141    remove_argument (N, &argc, argv);
     142  }
     143
     144  if ((N = get_argument (argc, argv, "-fminor"))) {
     145    remove_argument (N, &argc, argv);
     146    graphmode.fMinorXm = atof(argv[N]);
     147    graphmode.fMinorXp = atof(argv[N]);
     148    graphmode.fMinorYm = atof(argv[N]);
     149    graphmode.fMinorYp = atof(argv[N]);
     150    remove_argument (N, &argc, argv);
     151  }
     152  if ((N = get_argument (argc, argv, "-xfminor"))) {
     153    remove_argument (N, &argc, argv);
     154    graphmode.fMinorXm = atof(argv[N]);
     155    remove_argument (N, &argc, argv);
     156  }
     157  if ((N = get_argument (argc, argv, "+xfminor"))) {
     158    remove_argument (N, &argc, argv);
     159    graphmode.fMinorXp = atof(argv[N]);
     160    remove_argument (N, &argc, argv);
     161  }
     162  if ((N = get_argument (argc, argv, "-yfminor"))) {
     163    remove_argument (N, &argc, argv);
     164    graphmode.fMinorYm = atof(argv[N]);
     165    remove_argument (N, &argc, argv);
     166  }
     167  if ((N = get_argument (argc, argv, "+yfminor"))) {
     168    remove_argument (N, &argc, argv);
     169    graphmode.fMinorYp = atof(argv[N]);
     170    remove_argument (N, &argc, argv);
     171  }
     172
     173  if ((N = get_argument (argc, argv, "-flabel"))) {
     174    remove_argument (N, &argc, argv);
     175    graphmode.fLabelRangeXm = atof(argv[N]);
     176    graphmode.fLabelRangeXp = atof(argv[N]);
     177    graphmode.fLabelRangeYm = atof(argv[N]);
     178    graphmode.fLabelRangeYp = atof(argv[N]);
     179    remove_argument (N, &argc, argv);
     180  }
     181  if ((N = get_argument (argc, argv, "-xflabel"))) {
     182    remove_argument (N, &argc, argv);
     183    graphmode.fLabelRangeXm = atof(argv[N]);
     184    remove_argument (N, &argc, argv);
     185  }
     186  if ((N = get_argument (argc, argv, "+xflabel"))) {
     187    remove_argument (N, &argc, argv);
     188    graphmode.fLabelRangeXp = atof(argv[N]);
     189    remove_argument (N, &argc, argv);
     190  }
     191  if ((N = get_argument (argc, argv, "-yflabel"))) {
     192    remove_argument (N, &argc, argv);
     193    graphmode.fLabelRangeYm = atof(argv[N]);
     194    remove_argument (N, &argc, argv);
     195  }
     196  if ((N = get_argument (argc, argv, "+yflabel"))) {
     197    remove_argument (N, &argc, argv);
     198    graphmode.fLabelRangeYp = atof(argv[N]);
    141199    remove_argument (N, &argc, argv);
    142200  }
    … …  
    174232  gprint (GP_ERR, "         alternatively, set each axis independently with:\n");
    175233  gprint (GP_ERR, "        -xpad, -ypad, +xpad, +ypad\n");
     234  gprint (GP_ERR, "  \n");
     235  gprint (GP_ERR, "  -fminor : set the number of minor ticks per major (all axes)\n");
     236  gprint (GP_ERR, "         alternatively, set each axis independently with:\n");
     237  gprint (GP_ERR, "        -xfminor, -yfminor, +xfminor, +yfminor\n");
     238  gprint (GP_ERR, "  \n");
     239  gprint (GP_ERR, "  -flabel : set the fraction of axis over which major ticks have labels (all axes)\n");
     240  gprint (GP_ERR, "         alternatively, set each axis independently with:\n");
     241  gprint (GP_ERR, "        -xflabel, -yflabel, +xflabel, +yflabel\n");
    176242
    177243  return (FALSE);

  • trunk/Ohana/src/opihi/cmd.data/device.c

    r14590 r38986  
    66  char *name;;
    77  /* set / get current graphics device */
     8
     9  int QUIET = FALSE;
     10  if ((N = get_argument (argc, argv, "-q"))) {
     11    remove_argument (N, &argc, argv);
     12    QUIET = TRUE;
     13  }
    814
    915  name = NULL;
    … …  
    2329    if (!GetGraph (NULL, &kapa, name)) return (FALSE);
    2430  }
    25   gprint (GP_ERR, "kapa %s\n", name);
     31  if (!QUIET) gprint (GP_ERR, "kapa %s\n", name);
    2632
    2733  return (TRUE);

  • trunk/Ohana/src/opihi/cmd.data/read_vectors.c

    r38553 r38986  
    511511    if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension %d\n", Nextend);
    512512  } else {
    513     if (!gfits_fread_ftable_range (f, padIfShort, &table, start, Nrows)) ESCAPE ("error reading table for extension %d\n", Nextend);
     513    // arg3 (FALSE) : seek to this segment start
     514    if (!gfits_fread_ftable_range (f, padIfShort, FALSE, &table, start, Nrows)) ESCAPE ("error reading table for extension %d\n", Nextend);
    514515  }
    515516

  • trunk/Ohana/src/opihi/cmd.data/uniq.c

    r20936 r38986  
    11# include "data.h"
     2// NOTE: if there are only a few uniq values, the old algorithm is not bad. 
     3// for 10000 uniq values, 30M points take ~20sec in the new algorithm,
     4// 3M points takess 45 sec in the old method.
    25
    36int uniq (int argc, char **argv) {
    47 
    5   int Nnew, i, j, found;
     8  int Nnew, i, N;
    69  Vector *ivec, *ovec;
    710
     11  Vector *cvec = NULL;
     12  if ((N = get_argument (argc, argv, "-c"))) {
     13    remove_argument (N, &argc, argv);
     14    if ((cvec = SelectVector (argv[N], ANYVECTOR, TRUE)) == NULL) {
     15      gprint (GP_ERR, "invalid vector %s\n", argv[N]);
     16      return FALSE;
     17    }
     18    remove_argument (N, &argc, argv);
     19  }
     20
    821  if (argc != 3) {
    9     gprint (GP_ERR, "USAGE: uniq (in) (out)\n");
     22    gprint (GP_ERR, "USAGE: uniq (in) (out) -c count\n");
    1023    return (FALSE);
    1124  }
    … …  
    1629  /* allocate the maximum possible needed */
    1730  ResetVector (ovec, ivec->type, ivec->Nelements);
     31  if (cvec) {
     32    ResetVector (cvec, OPIHI_INT, ivec->Nelements);
     33  }
    1834
    1935  Nnew = 0;
    2036
    2137  if (ivec->type == OPIHI_FLT) {
    22     opihi_flt *v1 = ivec[0].elements.Flt;
    23     for (i = 0; i < ivec[0].Nelements; i++, v1++) {
    24       opihi_flt *v2 = ovec[0].elements.Flt;
    25       found = FALSE;
    26       for (j = 0; !found && (j < Nnew); j++, v2++) {
    27         if (*v1 == *v2) found = TRUE;
     38    // copy the input data to a temporary array to avoid damaging it with sort
     39    opihi_flt *indata = NULL;
     40    ALLOCATE (indata, opihi_flt, ivec[0].Nelements);
     41    memcpy (indata, ivec->elements.Flt, ivec[0].Nelements*sizeof(opihi_flt));
     42
     43    dsort (indata, ivec->Nelements);
     44
     45    Nnew = 0;
     46    opihi_flt *vtgt = ovec[0].elements.Flt;
     47
     48    opihi_flt *vsrc = indata;
     49
     50    for (i = 0; i < ivec->Nelements; Nnew++) {
     51      vtgt[Nnew] = *vsrc;
     52      int Ndup = 0;
     53      opihi_flt lastValue = *vsrc;
     54      while ((i < ivec->Nelements) && (*vsrc == lastValue)) {
     55        i++;
     56        vsrc ++;
     57        Ndup ++;
    2858      }
    29       if (!found) {
    30         ovec[0].elements.Flt[Nnew] = *v1;
    31         Nnew ++;
     59      if (cvec) {
     60        cvec->elements.Int[Nnew] = Ndup;
    3261      }
    3362    }
     63    free (indata);
    3464  } else {
    35     opihi_int *v1 = ivec[0].elements.Int;
    36     for (i = 0; i < ivec[0].Nelements; i++, v1++) {
    37       opihi_int *v2 = ovec[0].elements.Int;
    38       found = FALSE;
    39       for (j = 0; !found && (j < Nnew); j++, v2++) {
    40         if (*v1 == *v2) found = TRUE;
     65    // copy the input data to a temporary array to avoid damaging it with sort
     66    opihi_int *indata = NULL;
     67    ALLOCATE (indata, opihi_int, ivec[0].Nelements);
     68    memcpy (indata, ivec->elements.Int, ivec[0].Nelements*sizeof(opihi_int));
     69
     70    isort (indata, ivec->Nelements);
     71
     72    Nnew = 0;
     73    opihi_int *vtgt = ovec[0].elements.Int;
     74
     75    opihi_int *vsrc = indata;
     76
     77    for (i = 0; i < ivec->Nelements; Nnew++) {
     78      vtgt[Nnew] = *vsrc;
     79      int Ndup = 0;
     80      opihi_int lastValue = *vsrc;
     81      while ((i < ivec->Nelements) && (*vsrc == lastValue)) {
     82        i++;
     83        vsrc ++;
     84        Ndup ++;
    4185      }
    42       if (!found) {
    43         ovec[0].elements.Int[Nnew] = *v1;
    44         Nnew ++;
     86      if (cvec) {
     87        cvec->elements.Int[Nnew] = Ndup;
    4588      }
    4689    }
     90    free (indata);
    4791  }
    4892
    4993  // free up extra memory
    5094  ResetVector (ovec, ivec->type, Nnew);
     95  if (cvec) ResetVector (cvec, OPIHI_INT, Nnew);
    5196
    5297  return (TRUE);

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

    r38471 r38986  
    213213  }
    214214
    215   // int needLensing = dbFieldNeedLensing (fields, Nfields);
     215  int needLensing = dbFieldNeedLensing (fields, Nfields);
    216216  int needStarpar = dbFieldNeedStarpar (fields, Nfields, FALSE);
    217217
    … …  
    234234    catalog.filename = HOST_ID ? hostfile : skylist[0].filename[i];
    235235    catalog.catflags = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_SECFILT;
    236     // catalog.catflags |= needLensing ? DVO_LOAD_LENSING : DVO_SKIP_LENSING;
     236    catalog.catflags |= needLensing ? DVO_LOAD_LENSING : DVO_SKIP_LENSING;
    237237    catalog.catflags |= needStarpar ? DVO_LOAD_STARPAR : DVO_SKIP_STARPAR;
    238238    catalog.Nsecfilt = Nsecfilt;
    … …  
    274274        StarPar *starpar = needStarpar ? &catalog.starpar[Nstarpar] : NULL;
    275275
    276         // int Nlensing = average->lensobjOffset;
    277         // Lensobj *lensobj = needLensobj ? &catalog.lensobj[m] : NULL;
     276        int Nlensing = average->lensingOffset;
     277        Lensing *lensing = needLensing ? &catalog.lensing[Nlensing] : NULL;
    278278
    279279        int Nsec = j*Nsecfilt;
    … …  
    281281
    282282        for (n = 0; n < Nfields; n++) {
    283           values[n] = dbExtractMeasures (average, secfilt, &catalog.measure[m], NULL, starpar, &fields[n]);
     283          values[n] = dbExtractMeasures (average, secfilt, &catalog.measure[m], lensing, starpar, &fields[n]);
    284284        }
    285285        // fprintf (stderr, "object: ave: %f, cat: %f, averef %d\n", fields[n].name, values[2], values[3], catalog.measure[m].averef);

  • trunk/Ohana/src/opihi/lib.data/gaussian.c

    r3894 r38986  
    2020 
    2121  int i;
    22   long A, B;
    2322  double val, x, dx, dx1, dx2, dx3, df;
    2423  double mean, sigma;
    … …  
    2726  if (Ngaussint == Nbin) return;
    2827
    29   A = time(NULL);
    30   for (B = 0; A == time(NULL); B++);
    31   srand48(B);
     28  long A = time(NULL);
     29  srand48(A);
    3230 
    3331  Ngaussint = Nbin;

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

    r16900 r38986  
    3838  }
    3939
     40  // XXX this is a bit dangerous : answer may have an arbitrary
     41  // length, but we do not know the available space in 'ptr'
     42  // we really should be passing in the buffer size and limiting the copy
     43
     44
    4045  if (!strcmp (mode, "%s"))  strcpy ((char *) ptr, answer);
    4146  if (!strcmp (mode, "%d"))  *(int *) ptr       = atoi (answer);

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

    r32632 r38986  
    2323  status = gethostname (myHostname, HOST_NAME_MAX);
    2424
    25   fprintf (stderr, "target host: %s, real host: %s\n", hostname, myHostname);
     25  if (strcmp (hostname, myHostname)) {
     26    fprintf (stderr, "target host: %s, real host: %s\n", hostname, myHostname);
     27    fprintf (stderr, "please run on the correct host\n");
     28    exit (2);
     29  }
    2630
    2731  GetPortRange (&start, &stop, portinfo);
    … …  
    197201
    198202  host = gethostbyname (hostname);
     203  if (!host) {
     204    gprint (GP_ERR, "cannot connect to pantasks server %s\n", hostname);
     205    exit (3);
     206  }
     207
    199208  bzero (hostip, 80);
    200209  for (i = 0; i < host[0].h_length; i++) {

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

    r27592 r38986  
    255255  if (file == NULL) {
    256256    // XXX this is a problem: we are leaving open the old file
    257     fprintf (stderr, "cannot open file %s\n", stream[0].name);
     257    fprintf (stderr, "gprint cannot open file %s\n", stream[0].name);
    258258    free (stream[0].name);
    259259    file = (dest == GP_LOG) ? stdout : stderr;

  • trunk/Ohana/src/opihi/pantasks

  • trunk/Ohana/src/opihi/pantasks/CheckJobs.c

    r27614 r38986  
    11# include "pantasks.h"
     2static int Ncheck = 0;
    23
    34float CheckJobs () {
    … …  
    1213  float time_running, next_timeout;
    1314
    14   // int Ncheck;
    15   // Ncheck = 0;
     15  Ncheck ++;
    1616
    1717  // actual maximum delay is controlled in job_threads.c
    … …  
    2121  /** test all jobs: ready to test?  finished? **/
    2222  while ((job = NextJob ()) != NULL) {
    23     // Ncheck ++;
    2423
    2524    task = job[0].task;
    … …  
    220219    SetTaskTimer (&job[0].last);
    221220  }
    222   // fprintf (stderr, "check %d jobs\n", Ncheck);
     221
    223222  JobTaskUnlock();
    224223  return (next_timeout);

  • trunk/Ohana/src/opihi/pantasks/CheckTasks.c

    r31666 r38986  
    11# include "pantasks.h"
     2static int Ncheck = 0;
    23
    34float CheckTasks () {
    … …  
    78  int status;
    89  float time_running, next_timeout, fuzz;
     10
     11  Ncheck ++;
    912
    1013  // actual maximum delay is controlled in job_threads.c

  • trunk/Ohana/src/opihi/pantasks/TaskOps.c

    r36623 r38986  
    2222void FreeTasks () {
    2323  int i;
    24   for (i = 0; i < Ntasks; i++) {
     24  int ntasks = Ntasks;
     25  Ntasks = 0;
     26  for (i = 0; i < ntasks; i++) {
    2527    FreeTask (tasks[i]);
    2628  }

  • trunk/Ohana/src/opihi/pantasks/pantasks_server.c.in

    r32632 r38986  
    1919 
    2020  char hostname[256], portinfo[256];
    21   char log_stdout[1024], log_stderr[1024];
     21  char log_stdout[1024], log_stderr[1024], tmpname[1024];
    2222  pthread_t JobsAndTasksThread;
    2323  pthread_t clientsThread;
    … …  
    3434  stdin = freopen ("/dev/zero", "r", stdin);
    3535
    36   // this block redirects the actual stderr, stdout steams to the output files
    37   if (VarConfig ("PANTASKS_SERVER_STDOUT", "%s", log_stdout) != NULL) {
     36  // this block redirects the actual stderr, stdout streams to the output files
     37  if (VarConfig ("PANTASKS_SERVER_STDOUT", "%s", tmpname) != NULL) {
     38    strcpy (log_stdout, tmpname);
    3839    if (strcmp (log_stdout, "stdout")) {
    3940      stdout = freopen (log_stdout, "a", stdout);
    … …  
    4445    }
    4546  }
    46   if (VarConfig ("PANTASKS_SERVER_STDERR", "%s", log_stderr) != NULL) {
     47  if (VarConfig ("PANTASKS_SERVER_STDERR", "%s", tmpname) != NULL) {
     48    strcpy (log_stderr, tmpname);
    4749    if (strcmp (log_stderr, "stderr")) {
    4850      stderr = freopen (log_stderr, "a", stderr);

  • trunk/Ohana/src/opihi/pantasks/test/local.sh

    r10647 r38986  
    11
    22## a basic test of memory allocation
     3if (not($?VERBOSE)) set VERBOSE = 0
    34
    45exec rm -f tmp.txt
    … …  
    3839 $startmem = $word:1
    3940end
     41
    4042macro memcheck
    4143 list word -x "ps -p $PID -o rss"

  • trunk/Ohana/src/photdbc/Makefile

    r36833 r38986  
    1 default: photdbc photdbc_client dvodist
     1default: photdbc photdbc_client dvocompress dvocompress_client dvodist
    22help:
    3         @echo "make options: photdbc photdbc_client dvodist"
     3        @echo "make options: photdbc photdbc_client dvocompress dvocompress_client dvodist"
    44
    55include ../../Makefile.System
    … …  
    2020photdbc_client: $(BIN)/photdbc_client.$(ARCH)
    2121
     22dvocompress: $(BIN)/dvocompress.$(ARCH)
     23dvocompress_client: $(BIN)/dvocompress_client.$(ARCH)
     24
     25
    2226dvodist: $(BIN)/dvodist.$(ARCH)
    2327
    24 install: $(DESTBIN)/photdbc $(DESTBIN)/photdbc_client $(DESTBIN)/dvodist
     28install: $(DESTBIN)/photdbc $(DESTBIN)/photdbc_client $(DESTBIN)/dvocompress $(DESTBIN)/dvocompress_client $(DESTBIN)/dvodist
    2529
    2630PHOTDBC = \
    2731$(SRC)/photdbc.$(ARCH).o           \
    2832$(SRC)/photdbc_catalogs.$(ARCH).o  \
     33$(SRC)/SetSignals.$(ARCH).o        \
    2934$(SRC)/initialize.$(ARCH).o        \
    3035$(SRC)/ConfigInit.$(ARCH).o        \
    … …  
    3944$(SRC)/photdbc_client.$(ARCH).o    \
    4045$(SRC)/photdbc_catalogs.$(ARCH).o  \
     46$(SRC)/SetSignals.$(ARCH).o        \
    4147$(SRC)/initialize.$(ARCH).o        \
    4248$(SRC)/ConfigInit.$(ARCH).o        \
    … …  
    4551$(SRC)/join_stars.$(ARCH).o        \
    4652$(SRC)/make_subcatalog.$(ARCH).o       
     53
     54DVOCOMPRESS =                         \
     55$(SRC)/dvocompress.$(ARCH).o          \
     56$(SRC)/dvocompress_catalogs.$(ARCH).o \
     57$(SRC)/SetSignals.$(ARCH).o           \
     58$(SRC)/args_dvocompress.$(ARCH).o     \
     59$(SRC)/Shutdown.$(ARCH).o
     60
     61DVOCOMPRESS_CLIENT =                  \
     62$(SRC)/dvocompress_client.$(ARCH).o   \
     63$(SRC)/dvocompress_catalogs.$(ARCH).o \
     64$(SRC)/SetSignals.$(ARCH).o           \
     65$(SRC)/args_dvocompress.$(ARCH).o     \
     66$(SRC)/Shutdown.$(ARCH).o
    4767
    4868DVODIST = \
    … …  
    89109$(BIN)/photdbc_client.$(ARCH): $(PHOTDBC_CLIENT)
    90110
     111$(DVOCOMPRESS): $(INC)/dvocompress.h
     112$(BIN)/dvocompress.$(ARCH): $(DVOCOMPRESS)
     113
     114$(DVOCOMPRESS_CLIENT): $(INC)/dvocompress.h
     115$(BIN)/dvocompress_client.$(ARCH): $(DVOCOMPRESS_CLIENT)
     116
    91117$(DVODIST): $(INC)/dvodist.h
    92118$(BIN)/dvodist.$(ARCH): $(DVODIST)

  • trunk/Ohana/src/photdbc/src/Shutdown_dvodist.c

    r38441 r38986  
    4343  va_end (argp);
    4444
    45   // XXX this is in SetSignals.c, which includes photdbc.h
    46   SetProtect (TRUE);
    47   gfits_db_close (&db);
    4845  fprintf (stderr, "ERROR: dvodist halted\n");
    4946  exit (1);

  • trunk/Ohana/src/photdbc/src/copy_images.c

    r38441 r38986  
    5959  char mapfile[DVO_MAX_PATH];
    6060  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
    61   AstromOffsetTable *table_src = AstromOffsetMapLoad (mapfile, VERBOSE);
     61  AstromOffsetTable *table_src = AstromOffsetMapLoad (mapfile, 100000, VERBOSE);
    6262
    6363  // assign images.coords.offsetMap -> table->map[i]

  • trunk/Ohana/src/photdbc/src/photdbc.c

    r38062 r38986  
    77
    88  /* get configuration info, args, lockfile */
     9  SetSignals ();
    910  initialize (argc, argv);
    1011

  • trunk/Ohana/src/photdbc/src/photdbc_catalogs.c

    r38471 r38986  
    8282    // get_mags (catalog);
    8383
    84     dvo_catalog_save (&outcatalog, VERBOSE);
    85     dvo_catalog_unlock (&outcatalog);
     84    SetProtect (TRUE);
     85    if (!dvo_catalog_save (&outcatalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", outcatalog.filename); exit (1); }
     86    if (!dvo_catalog_unlock (&outcatalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", outcatalog.filename); exit (1); }
     87    SetProtect (FALSE);
     88
    8689    dvo_catalog_free (&outcatalog);
    8790

  • trunk/Ohana/src/photdbc/src/photdbc_client.c

    r38062 r38986  
    33int main (int argc, char **argv) {
    44
     5  SetSignals ();
    56  initialize_client (argc, argv);
    67

  • trunk/Ohana/src/relastro/Makefile

    r38062 r38986  
    2020relastro_client: $(BIN)/relastro_client.$(ARCH)
    2121
    22 install: $(DESTBIN)/relastro $(DESTBIN)/relastro_client $(DESTBIN)/testparallax
     22install: $(DESTBIN)/relastro $(DESTBIN)/relastro_client
     23
     24# $(DESTBIN)/testparallax
    2325
    2426RELASTRO = \
    … …  
    2628$(SRC)/FitChip.$(ARCH).o             \
    2729$(SRC)/FitMosaic.$(ARCH).o           \
     30$(SRC)/FitSimple.$(ARCH).o           \
     31$(SRC)/FitAstromOps.$(ARCH).o           \
    2832$(SRC)/FitPM.$(ARCH).o               \
    29 $(SRC)/FitPar.$(ARCH).o              \
    3033$(SRC)/FitPMandPar.$(ARCH).o         \
    31 $(SRC)/FitSimple.$(ARCH).o           \
     34$(SRC)/FitPosPMfixed.$(ARCH).o       \
    3235$(SRC)/ImageOps.$(ARCH).o            \
    3336$(SRC)/MosaicOps.$(ARCH).o           \
    … …  
    99102RELASTRO_CLIENT = \
    100103$(SRC)/ConfigInit.$(ARCH).o          \
     104$(SRC)/FitSimple.$(ARCH).o           \
     105$(SRC)/FitAstromOps.$(ARCH).o           \
    101106$(SRC)/FitPM.$(ARCH).o               \
    102 $(SRC)/FitPar.$(ARCH).o              \
    103107$(SRC)/FitPMandPar.$(ARCH).o         \
    104 $(SRC)/FitSimple.$(ARCH).o           \
     108$(SRC)/FitPosPMfixed.$(ARCH).o       \
    105109$(SRC)/ImageOps.$(ARCH).o            \
    106110$(SRC)/MosaicOps.$(ARCH).o           \

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

    r38441 r38986  
    2828
    2929typedef enum {TARGET_NONE, TARGET_SIMPLE, TARGET_CHIPS, TARGET_MOSAICS} FitTarget;
     30
     31typedef enum {
     32  FIT_RESULT_RA,
     33  FIT_RESULT_DEC,
     34  FIT_RESULT_uR,
     35  FIT_RESULT_uD,
     36  FIT_RESULT_PLX,
     37} FitAstromResultMode;
    3038
    3139typedef enum {
    … …  
    115123  double Ro, dRo;
    116124  double Do, dDo;
    117 
    118125  double uR, duR;
    119126  double uD, duD;
    120 
    121   double p, dp;
     127  double  p, dp;
    122128
    123129  double chisq;
    124130  int Nfit;
    125 } PMFit;
     131} FitAstromResult;
     132
     133typedef struct {
     134  double **A;
     135  double **B;
     136  int Nterms;
     137} FitAstromData;
     138
     139typedef struct {
     140  double X, dX;
     141  double Y, dY;
     142  double R, dR;
     143  double D, dD;
     144  double T, dT;
     145  double pR;
     146  double pD;
     147  double C_blue;
     148  double C_red;
     149  int measure;
     150} FitAstromPoint;
     151
     152typedef struct {
     153  off_t Nave;
     154  off_t Npm;
     155  off_t Npar;
     156  off_t Nskip;
     157  off_t Noffset;
     158
     159  double *values;
     160  FitAstromResult *fit; // use bootstrap resampling to generate Nfit fits to measure the stats
     161  int Nfit;
     162  int NfitAlloc;
     163
     164  FitAstromPoint *points;
     165  FitAstromPoint *sample;
     166  int Npoints;
     167  int NpointsAlloc;
     168
     169  FitAstromData *fitdataPos;
     170  FitAstromData *fitdataPM;
     171  FitAstromData *fitdataPar;
     172
     173  Coords coords;
     174  time_t T2000;
     175} FitStats;
    126176
    127177typedef struct {
    … …  
    150200
    151201typedef struct {
    152   off_t Nave;
    153   off_t Npm;
    154   off_t Npar;
    155   off_t Nskip;
    156   off_t Noffset;
    157 } FitStats;
    158 
    159 typedef struct {
    160202  double scale;
    161203  double **Roff;
    … …  
    180222  int Nicrfobj;
    181223} ICRFobj;
     224
     225# define ID_MEAS_OBJECT_HAS_2MASS ID_MEAS_POOR_PHOTOM
    182226
    183227/* global variables set in parameter file */
    … …  
    224268int    PARALLEL_OUTPUT;
    225269
     270int    VERBOSE_IMAGE;
     271
    226272int    VERBOSE;
    227273int    VERBOSE2;
    … …  
    234280int    USE_ICRF_SHFIT;
    235281int    USE_ICRF_POLE;
     282
     283int    USE_ALL_IMAGES;
    236284
    237285int    RESET;
    … …  
    252300int    CHIPORDER;
    253301int    CHIPMAP;
     302
     303int    N_BOOTSTRAP_SAMPLES;
    254304
    255305int MaxDensityUse;
    … …  
    369419int           liststats_pos       PROTO((double *value, double *dvalue, int N, StatType *stats, int XVERB));
    370420Catalog      *load_catalogs       PROTO((SkyList *skylist, int *Ncatalog, int subselect, int hostID, char *hostpath, char *syncfile));
    371 int           load_images         PROTO((FITS_DB *db, SkyList *skylist, int UseFullOverlap));
     421int           load_images         PROTO((FITS_DB *db, SkyList *skylist, int UseFullOverlap, int UseAllImages));
    372422Image        *select_images       PROTO((SkyList *skylist, Image *timage, off_t Ntimage, off_t **LineNumber, off_t *Nimage, int UseFullOverlap));
    373423
    … …  
    448498int UpdateObjects (Catalog *catalog, int Ncatalog, int Nloop);
    449499int UpdateSimple (Catalog *catalog, int Ncatalog);
    450 int UpdateChips (Catalog *catalog, int Ncatalog);
     500int UpdateChips (Catalog *catalog, int Ncatalog, int Nloop);
    451501int UpdateMosaic (Catalog *catalog, int Ncatalog);
    452502int UpdateMeasures (Catalog *catalog, int Ncatalog);
    … …  
    457507
    458508int sun_ecliptic (double jd, double *lambda, double *beta, double *epsilon, double *Radius);
    459 int ParFactor (double *pR, double *pD, double RA, double Dec, double Time, double Tmean);
    460 int FitPM (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *T, int Npts, int XVERB);
    461 int FitPar (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *pR, double *pD, int Npts);
    462 int FitPMandPar (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *T, double *pR, double *pD, int Npts, int XVERB);
     509int ParFactor (double *pR, double *pD, double RA, double Dec, double Time);
     510int FitPM (FitAstromResult *fit, FitAstromData *data, FitAstromPoint *points, int Npoints);
     511int FitPMandPar (FitAstromResult *fit, FitAstromData *data, FitAstromPoint *points, int Npoints);
     512int FitPosPMfixed (FitAstromResult *fit, FitAstromData *data, FitAstromPoint *points, int Npoints);
    463513
    464514Mosaic *getMosaicForImage (off_t N);
    … …  
    661711int client_logger_init (char *dirname);
    662712int client_logger_message (char *format,...);
     713
     714int FitAstromSetChisq (FitAstromResult *fit, FitAstromPoint *points, int Npoints, FitMode mode);
     715double VectorFractionInterpolate (double *values, float fraction, int Npts);
     716int BootstrapRobustStats (FitAstromResult *result, FitAstromResult *fit, int Nfit, int mode);
     717int BootstrapResample (FitAstromPoint *sample, FitAstromPoint *points, int Npoints);
     718int CatalogMaxNmeasure (Catalog *catalog, int Ncatalog);
     719int FitAstromPoints_Project (FitStats *fitStats, double *Tmean, double *Trange, double *parRange);
     720int UpdateObjects_SelectMeasures (FitStats *fit, Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int isStack);
     721int UpdateObjects_Stack (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats);
     722int UpdateObjects_Chips (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats, int cat, off_t measOff);
     723
     724void FitAstromResultInit (FitAstromResult *fit);
     725void FitAstromPointInit (FitAstromPoint *object);
     726void FitAstromDataFree (FitAstromData *fit);
     727FitAstromData *FitAstromDataInit (int Nterms);
     728void FitStatsFree (FitStats *fitStats);
     729void FitStatsSum (FitStats *src, FitStats *tgt);
     730void FitStatsReset (FitStats *tgt);
     731FitStats *FitStatsInit (int Nmax, int Nboot);
     732int FitAstromResultSetPM (FitAstromResult *fit, int Nfit, Average *average);
     733void AstromErrorSetLoop (int Nloop, int isImageMode);

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

    r37807 r38986  
    8181    }
    8282
    83     if (VERBOSE2) fprintf (stderr, "using %d for %s\n", order_use, image[0].name);
     83    if (VERBOSE2) {
     84      fprintf (stderr, "using %d for %s\n", order_use, image[0].name);
     85    }
    8486
    8587    // when fitting the map, first fit a linear model (below? change Npolyterms to -1)
    … …  
    9294    for (i = 0; i < Nmatch; i++) {
    9395      if (raw[i].mask) continue;
    94       fit_add (fit, raw[i].X, raw[i].Y, ref[i].L, ref[i].M, raw[i].dPos);
     96      fit_add (fit, raw[i].X, raw[i].Y, ref[i].L, ref[i].M, ref[i].dPos);
    9597    }
    9698
    … …  
    310312  int i, N;
    311313
    312   float *x, *y, *dX, *dY;
     314  float *x, *y, *dX, *dY, *dP;
    313315  ALLOCATE (x,  float, Npts);
    314316  ALLOCATE (y,  float, Npts);
    315317  ALLOCATE (dX, float, Npts);
    316318  ALLOCATE (dY, float, Npts);
     319  ALLOCATE (dP, float, Npts);
    317320
    318321  N = 0;
    … …  
    323326    dX[N] = ref[i].X - raw[i].X;
    324327    dY[N] = ref[i].Y - raw[i].Y;
     328    dP[N] = ref[i].dPos;
    325329    N++;
    326330  }
    … …  
    329333  // (L,M) = f(X',Y') : (X',Y') = (X,Y) + (dX,dY)
    330334
    331   AstromOffsetMapFit (map, x, y, dX, N, TRUE);
    332   AstromOffsetMapFit (map, x, y, dY, N, FALSE);
     335  AstromOffsetMapFit (map, x, y, dX, dP, N, TRUE);
     336  AstromOffsetMapFit (map, x, y, dY, dP, N, FALSE);
    333337
    334338  AstromOffsetMapRepair (map, TRUE);
    … …  
    339343  free (dX);
    340344  free (dY);
     345  free (dP);
    341346
    342347  return TRUE;

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

    r32695 r38986  
    11# include "relastro.h"
    22
    3 /* do we want an init function which does the alloc and a clear function to free? */
    4 int FitPM (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *T, int Npts, int XVERB) {
     3// initial values of *fit are ignored
     4int FitPM (FitAstromResult *fit, FitAstromData *data, FitAstromPoint *points, int Npoints) {
    55
    66  int i;
    77
    8   double **A, **B;
    98  double wx, wy, Wx, Wy, Tx, Ty, Tx2, Ty2, Xs, Ys, XT, YT;
    10   double chisq, Xf, Yf;
    119
    12   /* do I need to do this as 2 2x2 matrix equations? */
    13   A = array_init (4, 4);
    14   B = array_init (4, 1);
     10  myAssert (data->Nterms == 4, "invalid fit arrays");
    1511
    1612  Wx = Wy = Tx = Ty = Tx2 = Ty2 = Xs = Ys = XT = YT = 0.0;
    17   for (i = 0; i < Npts; i++) {
     13
     14  for (i = 0; i < Npoints; i++) {
    1815    /* handle case where dX or dY = 0.0 */
    19     wx = 1.0 / SQ(dX[i]);
    20     wy = 1.0 / SQ(dY[i]);
     16    wx = 1.0 / SQ(points[i].dX);
     17    wy = 1.0 / SQ(points[i].dY);
    2118
    2219    Wx += wx;
    2320    Wy += wy;
    2421
    25     Tx += T[i]*wx;
    26     Ty += T[i]*wy;
     22    Tx += points[i].T*wx;
     23    Ty += points[i].T*wy;
    2724   
    28     Tx2 += SQ(T[i])*wx;
    29     Ty2 += SQ(T[i])*wy;
     25    Tx2 += SQ(points[i].T)*wx;
     26    Ty2 += SQ(points[i].T)*wy;
    3027   
    31     Xs += X[i]*wx;
    32     Ys += Y[i]*wy;
     28    Xs += points[i].X*wx;
     29    Ys += points[i].Y*wy;
    3330
    34     XT += X[i]*T[i]*wx;
    35     YT += Y[i]*T[i]*wy;
     31    XT += points[i].X*points[i].T*wx;
     32    YT += points[i].Y*points[i].T*wy;
    3633  }
    3734
    38   A[0][0] = Wx;
    39   A[0][1] = Tx;
     35  data->A[0][0] = Wx;
     36  data->A[0][1] = Tx;
    4037
    41   A[1][0] = Tx;
    42   A[1][1] = Tx2;
     38  data->A[1][0] = Tx;
     39  data->A[1][1] = Tx2;
    4340
    44   A[2][2] = Wy;
    45   A[2][3] = Ty;
     41  data->A[2][2] = Wy;
     42  data->A[2][3] = Ty;
    4643
    47   A[3][2] = Ty;
    48   A[3][3] = Ty2;
     44  data->A[3][2] = Ty;
     45  data->A[3][3] = Ty2;
    4946
    50   B[0][0] = Xs;
    51   B[1][0] = XT;
    52   B[2][0] = Ys;
    53   B[3][0] = YT;
     47  data->B[0][0] = Xs;
     48  data->B[1][0] = XT;
     49  data->B[2][0] = Ys;
     50  data->B[3][0] = YT;
    5451
    55   dgaussjordan (A, B, 4, 1);
     52  dgaussjordan (data->A, data->B, 4, 1);
    5653
    57   fit[0].Ro = B[0][0];
    58   fit[0].uR = B[1][0];
    59   fit[0].Do = B[2][0];
    60   fit[0].uD = B[3][0];
    61   fit[0].p  = 0.0;
     54  fit->Ro = data->B[0][0];
     55  fit->uR = data->B[1][0];
     56  fit->Do = data->B[2][0];
     57  fit->uD = data->B[3][0];
     58  fit->p  = 0.0;
    6259 
    63   fit[0].dRo = sqrt(A[0][0]);
    64   fit[0].duR = sqrt(A[1][1]);
    65   fit[0].dDo = sqrt(A[2][2]);
    66   fit[0].duD = sqrt(A[3][3]);
    67   fit[0].dp  = 0.0;
     60  fit->dRo = sqrt(data->A[0][0]);
     61  fit->duR = sqrt(data->A[1][1]);
     62  fit->dDo = sqrt(data->A[2][2]);
     63  fit->duD = sqrt(data->A[3][3]);
     64  fit->dp  = 0.0;
    6865 
    69   array_free (A, 4);
    70   array_free (B, 4);
     66  fit->Nfit = Npoints;
    7167
    72   // add up the chi square for the fit
    73   chisq = 0.0;
    74   for (i = 0; i < Npts; i++) {
    75     Xf = fit[0].Ro + fit[0].uR*T[i];
    76     Yf = fit[0].Do + fit[0].uD*T[i];
    77     chisq += SQ(X[i] - Xf) / SQ(dX[i]);
    78     chisq += SQ(Y[i] - Yf) / SQ(dY[i]);
    79     if (XVERB) fprintf (stderr, "chisq contrib : %f %f : %f %f : %f %f : %f %f : %f\n", Xf, Yf, X[i] - Xf, Y[i] - Yf, dX[i], dY[i], (X[i] - Xf) / dX[i], (Y[i] - Yf) / dY[i], chisq);
    80   }
    81   fit[0].Nfit = Npts;
    82 
    83   // the reduced chisq is divided by (Ndof = 2*Npts - 4)
    84   fit[0].chisq = chisq / (2.0*Npts - 4.0);
    8568  return (TRUE);
    8669}
    87 
    88 // XXX this function should (optionally?) iterate and clip outlier detections

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

    r32695 r38986  
    11# include "relastro.h"
    22
    3 /* do we want an init function which does the alloc and a clear function to free? */
    4 int FitPMandPar (PMFit *fit, double *X, double *dX, double *Y, double *dY, double *T, double *pR, double *pD, int Npts, int XVERB) {
     3// initial values of *fit are ignored
     4int FitPMandPar (FitAstromResult *fit, FitAstromData *data, FitAstromPoint *points, int Npoints) {
    55
    66  int i;
    77
    8   double **A, **B;
    98  double wx, wy, Wx, Wy, Tx, Ty, Tx2, Ty2, Xs, Ys, XT, YT;
    109  double PR, PD, PRT, PDT, PRX, PDY, PR2, PD2;
    11   double chisq, Xf, Yf;
    1210
    13   A = array_init (5, 5);
    14   B = array_init (5, 1);
     11  myAssert (data->Nterms == 5, "invalid fit arrays");
    1512
    1613  PR = PD = PRT = PDT = PRX = PDY = PR2 = PD2 = 0.0;
    1714  Wx = Wy = Tx = Ty = Tx2 = Ty2 = Xs = Ys = XT = YT = 0.0;
    18   for (i = 0; i < Npts; i++) {
     15
     16  for (i = 0; i < Npoints; i++) {
    1917    /* handle case where dX or dY = 0.0 */
    20     wx = 1.0 / SQ(dX[i]);
    21     wy = 1.0 / SQ(dY[i]);
     18    wx = 1.0 / SQ(points[i].dX);
     19    wy = 1.0 / SQ(points[i].dY);
    2220
    2321    Wx += wx;
    2422    Wy += wy;
    2523
    26     Tx += T[i]*wx;
    27     Ty += T[i]*wy;
     24    Tx += points[i].T*wx;
     25    Ty += points[i].T*wy;
    2826   
    29     Tx2 += SQ(T[i])*wx;
    30     Ty2 += SQ(T[i])*wy;
     27    Tx2 += SQ(points[i].T)*wx;
     28    Ty2 += SQ(points[i].T)*wy;
    3129   
    32     PR += pR[i]*wx;
    33     PD += pD[i]*wy;
     30    PR += points[i].pR*wx;
     31    PD += points[i].pD*wy;
    3432   
    35     PRT += pR[i]*T[i]*wx;
    36     PDT += pD[i]*T[i]*wy;
     33    PRT += points[i].pR*points[i].T*wx;
     34    PDT += points[i].pD*points[i].T*wy;
    3735   
    38     PRX += pR[i]*X[i]*wx;
    39     PDY += pD[i]*Y[i]*wy;
     36    PRX += points[i].pR*points[i].X*wx;
     37    PDY += points[i].pD*points[i].Y*wy;
    4038   
    41     PR2 += SQ(pR[i])*wx;
    42     PD2 += SQ(pD[i])*wy;
     39    PR2 += SQ(points[i].pR)*wx;
     40    PD2 += SQ(points[i].pD)*wy;
    4341
    44     Xs += X[i]*wx;
    45     Ys += Y[i]*wy;
     42    Xs += points[i].X*wx;
     43    Ys += points[i].Y*wy;
    4644
    47     XT += X[i]*T[i]*wx;
    48     YT += Y[i]*T[i]*wy;
     45    XT += points[i].X*points[i].T*wx;
     46    YT += points[i].Y*points[i].T*wy;
    4947  }
    5048
    51   A[0][0] = Wx;
    52   A[0][1] = Tx;
    53   A[0][4] = PR;
     49  data->A[0][0] = Wx;
     50  data->A[0][1] = Tx;
     51  data->A[0][4] = PR;
    5452
    55   A[1][0] = Tx;
    56   A[1][1] = Tx2;
    57   A[1][4] = PRT;
     53  data->A[1][0] = Tx;
     54  data->A[1][1] = Tx2;
     55  data->A[1][4] = PRT;
    5856
    59   A[2][2] = Wy;
    60   A[2][3] = Ty;
    61   A[2][4] = PD;
     57  data->A[2][2] = Wy;
     58  data->A[2][3] = Ty;
     59  data->A[2][4] = PD;
    6260
    63   A[3][2] = Ty;
    64   A[3][3] = Ty2;
    65   A[3][4] = PDT;
     61  data->A[3][2] = Ty;
     62  data->A[3][3] = Ty2;
     63  data->A[3][4] = PDT;
    6664
    67   A[4][0] = PR;
    68   A[4][1] = PRT;
    69   A[4][2] = PD;
    70   A[4][3] = PDT;
    71   A[4][4] = PR2 + PD2;
     65  data->A[4][0] = PR;
     66  data->A[4][1] = PRT;
     67  data->A[4][2] = PD;
     68  data->A[4][3] = PDT;
     69  data->A[4][4] = PR2 + PD2;
    7270
    73   B[0][0] = Xs;
    74   B[1][0] = XT;
    75   B[2][0] = Ys;
    76   B[3][0] = YT;
    77   B[4][0] = PRX + PDY;
     71  data->B[0][0] = Xs;
     72  data->B[1][0] = XT;
     73  data->B[2][0] = Ys;
     74  data->B[3][0] = YT;
     75  data->B[4][0] = PRX + PDY;
    7876
    79   dgaussjordan (A, B, 5, 1);
     77  dgaussjordan (data->A, data->B, 5, 1);
    8078
    81   fit[0].Ro = B[0][0];
    82   fit[0].uR = B[1][0];
    83   fit[0].Do = B[2][0];
    84   fit[0].uD = B[3][0];
    85   fit[0].p  = B[4][0];
     79  fit->Ro = data->B[0][0];
     80  fit->uR = data->B[1][0];
     81  fit->Do = data->B[2][0];
     82  fit->uD = data->B[3][0];
     83  fit->p  = data->B[4][0];
    8684 
    87   fit[0].dRo = sqrt(A[0][0]);
    88   fit[0].duR = sqrt(A[1][1]);
    89   fit[0].dDo = sqrt(A[2][2]);
    90   fit[0].duD = sqrt(A[3][3]);
    91   fit[0].dp  = sqrt(A[4][4]);
     85  fit->dRo = sqrt(data->A[0][0]);
     86  fit->duR = sqrt(data->A[1][1]);
     87  fit->dDo = sqrt(data->A[2][2]);
     88  fit->duD = sqrt(data->A[3][3]);
     89  fit->dp  = sqrt(data->A[4][4]);
    9290 
    93   array_free (A, 5);
    94   array_free (B, 5);
     91  fit->Nfit = Npoints;
    9592
    96   /* get the chisq from the matrix values */
    97 
    98   // add up the chi square for the fit
    99   chisq = 0.0;
    100   for (i = 0; i < Npts; i++) {
    101     Xf = fit[0].Ro + fit[0].uR*T[i] + fit[0].p*pR[i];
    102     Yf = fit[0].Do + fit[0].uD*T[i] + fit[0].p*pD[i];
    103     chisq += SQ(X[i] - Xf) / SQ(dX[i]);
    104     chisq += SQ(Y[i] - Yf) / SQ(dY[i]);
    105     if (XVERB) fprintf (stderr, "chisq contrib : %f %f : %f %f : %f %f : %f %f : %f\n", Xf, Yf, X[i] - Xf, Y[i] - Yf, dX[i], dY[i], (X[i] - Xf) / dX[i], (Y[i] - Yf) / dY[i], chisq);
    106 
    107   }
    108   fit[0].Nfit = Npts;
    109 
    110   // the reduced chisq is divided by (Ndof = 2*Npts - 5)
    111   fit[0].chisq = chisq / (2.0*Npts - 5.0);
    11293  return (TRUE);
    11394}

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

    r38062 r38986  
    479479    }
    480480
    481     AstromOffsetMapFit (map, Xfit, Yfit, dXfit, Nkeep, TRUE);
    482     AstromOffsetMapFit (map, Xfit, Yfit, dYfit, Nkeep, FALSE);
     481    AstromOffsetMapFit (map, Xfit, Yfit, dXfit, NULL, Nkeep, TRUE);
     482    AstromOffsetMapFit (map, Xfit, Yfit, dYfit, NULL, Nkeep, FALSE);
    483483
    484484    for (i = 0; i < Npts; i++) {

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

    r38553 r38986  
    240240  float *buffer = (float *)matrix->buffer;
    241241
    242   float **value = (raDirection) ? map->dXv : map->dYv;
     242  float *value = (raDirection) ? map->dXv : map->dYv;
    243243
    244244  int ix, iy;
    245245  for (ix = 0; ix < map->Nx; ix++) {
    246246    for (iy = 0; iy < map->Ny; iy++) {
    247       buffer[ix + map->Nx*iy] = value[ix][iy];
     247      buffer[ix + map->Nx*iy] = value[ix + map->Nx*iy];
    248248    }
    249249  }
    … …  
    265265  float *buffer = (float *) matrix->buffer;
    266266
    267   float **value = (raDirection) ? map->dXv : map->dYv;
     267  float *value = (raDirection) ? map->dXv : map->dYv;
    268268
    269269  int ix, iy;
    270270  for (ix = 0; ix < map->Nx; ix++) {
    271271    for (iy = 0; iy < map->Ny; iy++) {
    272       value[ix][iy] = buffer[ix + map->Nx*iy];
     272      value[ix + map->Nx*iy] = buffer[ix + map->Nx*iy];
    273273    }
    274274  }

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

    r36833 r38986  
    11# include "relastro.h"
    22# define WEIGHTED_ERRORS 1
     3
     4// XXX hard-wire the trends identified by CZW
     5static float BrightMo[] = {-15.6, -16.8, -17.0, -16.7, -16.0};
     6static float BrightMs[] = {1.3, 1.3, 1.3, 1.8, 2.0};
     7
     8static int Nloop = -1;
     9static int isImage = FALSE;
     10
     11// Nloop is used to modify the per detection errors
     12void AstromErrorSetLoop (int N, int isImageMode) {
     13  Nloop = N;
     14  isImage = isImageMode;
     15}
    316
    417float GetAstromErrorTiny (MeasureTiny *measure, int mode) {
    … …  
    4154  dPtotal = sqrt(SQ(dPsys) + SQ(AS*dPobs) + SQ(MS*dM));
    4255
     56  // for GPC1 data, we have a bright end model:
     57  if ((measure[0].photcode > 10000) && (measure[0].photcode < 10480)) {
     58    int Np = ((int) (measure[0].photcode / 100)) % 100;
     59    myAssert (Np >= 0, "oops");
     60    myAssert (Np <= 4, "oops");
     61
     62    float Minst = measure[0].M - measure[0].dt - 25.0;
     63    float dPbright = 0.335 / (1.0 + exp(BrightMs[Np]*(Minst - BrightMo[Np])));
     64    dPtotal = hypot(dPtotal, dPbright);
     65  }
    4366  dPtotal = MAX (dPtotal, MIN_ERROR);
     67
     68  // early on, we want 2MASS and Tycho to have a very high weight.  This will force images
     69  // to match the 2MASS / Tycho / ICRS reference frame.  As Nloop gets higher, the weight
     70  // needs to drop to allow the ps1 measurements to drive the solution
     71  int is2MASS  = USE_GALAXY_MODEL && !isImage && (measure[0].photcode >= 2011) && (measure[0].photcode <= 2013);
     72  int isTycho  = USE_GALAXY_MODEL && !isImage && (measure[0].photcode >= 2020) && (measure[0].photcode <= 2021);
     73  int has2MASS = USE_GALAXY_MODEL &&  isImage && (measure[0].dbFlags & ID_MEAS_OBJECT_HAS_2MASS);
     74
     75  // serious hack: if the object has 2MASS, we set this internal bit and adjust the
     76  // weight to ensure the image is tied down to the 2mass frame
     77
     78  if (has2MASS) {
     79    switch (Nloop) {
     80      case 0:
     81        dPtotal = dPtotal / 1000.0;
     82        break;
     83      case 1:
     84        dPtotal = dPtotal / 300.0;
     85        break;
     86      case 2:
     87        dPtotal = dPtotal / 100.0;
     88        break;
     89      case 3:
     90        dPtotal = dPtotal / 30.0;
     91        break;
     92      case 4:
     93        dPtotal = dPtotal / 10.0;
     94        break;
     95      case 5:
     96        dPtotal = dPtotal / 10.0;
     97        break;
     98      default:
     99        break;
     100    }
     101  }
     102  if (is2MASS) {
     103    switch (Nloop) {
     104      case 0:
     105        dPtotal = dPtotal / 1000.0;
     106        break;
     107      case 1:
     108        dPtotal = dPtotal / 300.0;
     109        break;
     110      case 2:
     111        dPtotal = dPtotal / 100.0;
     112        break;
     113      case 3:
     114        dPtotal = dPtotal / 30.0;
     115        break;
     116      case 4:
     117        dPtotal = dPtotal / 10.0;
     118        break;
     119      case 5:
     120        dPtotal = dPtotal / 10.0;
     121        break;
     122      default:
     123        break;
     124    }
     125  }
     126  if (isTycho) {
     127    switch (Nloop) {
     128      case 0:
     129      case 1:
     130        dPtotal = dPtotal / 200.0;
     131        break;
     132      case 2:
     133      case 3:
     134        dPtotal = dPtotal / 100.0;
     135        break;
     136      case 4:
     137      case 5:
     138        dPtotal = dPtotal / 50.0;
     139        break;
     140      default:
     141        break;
     142    }
     143  }
     144
    44145  return (dPtotal);
    45146}
    … …  
    84185  dPtotal = sqrt(SQ(dPsys) + SQ(AS*dPobs) + SQ(MS*dM));
    85186
     187  // for GPC1 data, we have a bright end model:
     188  if ((measure[0].photcode > 10000) && (measure[0].photcode < 10480)) {
     189    int Np = ((int) (measure[0].photcode / 100)) % 100;
     190    myAssert (Np >= 0, "oops");
     191    myAssert (Np <= 4, "oops");
     192
     193    float Minst = measure[0].M - measure[0].dt - 25.0;
     194    float dPbright = 0.335 / (1.0 + exp(BrightMs[Np]*(Minst - BrightMo[Np])));
     195    dPtotal = hypot(dPtotal, dPbright);
     196  }
     197
    86198  dPtotal = MAX (dPtotal, MIN_ERROR);
    87199  return (dPtotal);

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

    r38062 r38986  
    11# include "relastro.h"
     2int isGPC1chip (int photcode);
    23
    34# define USE_IMAGE_ID 1
    … …  
    690691      raw[i].mask |= MARK_NAN_POS_ERROR;
    691692    }
     693
     694    // XXX A TEST: can we use only 2MASS measurements to fit the images?
     695    // XXX Do NOT apply this for the real calibration
     696    if (FALSE && !(measure[0].dbFlags & ID_MEAS_OBJECT_HAS_2MASS)) {
     697      fprintf (stderr, "@");
     698      raw[i].mask |= MARK_BIG_OFFSET;
     699    }
     700
    692701    raw[i].Nmeas = catalog[c].average[n].Nmeasure; // record so we can check how well connected an image is
    693702
    … …  
    751760    ref[i].R = catalog[c].average[n].R;
    752761    ref[i].D = catalog[c].average[n].D;
     762   
     763    // if we are applying the galaxy model, move the reference position...
     764    if (USE_GALAXY_MODEL) {
     765      // apply proper-motion from average position to measure epoch:
     766      float dTime = (measure[0].t - catalog[c].average[n].Tmean) / (86400*365.25) ; // time relative to Tmean in years
     767
     768      // XXX do this in a better way?
     769      ref[i].R += dTime * catalog[c].average[n].uR / 3600.0 / cos(ref[i].D*RAD_DEG);
     770      ref[i].D += dTime * catalog[c].average[n].uD / 3600.0;
     771    }
    753772
    754773    // if we are correcting for the Galaxy Motion Model, we assume the mean R,D is at the J2000 epoch position
    755     if (USE_GALAXY_MODEL) {
     774    if (0) {
    756775      myAssert (!isnan(measure[0].RoffGAL), "oops");
    757776      myAssert (!isnan(measure[0].DoffGAL), "oops");
    … …  
    9811000  if (VERBOSE) fprintf (stderr, "%d measures marked poor, %d total\n", Ndel, Nave);
    9821001  free (R);
    983   free(dR);
    984   free(D);
    985   free(dD);
     1002  free (dR);
     1003  free (D);
     1004  free (dD);
    9861005}
    9871006
    … …  
    11101129  if (VERBOSE) fprintf (stderr, "%d measures marked poor, %d total\n", Ndel, Nave);
    11111130  free (R);
    1112   free(dR);
    1113   free(D);
    1114   free(dD);
    1115   free(d2);
    1116   free(index);
     1131  free (dR);
     1132  free (D);
     1133  free (dD);
     1134  free (d2);
     1135  free (index);
    11171136}
    11181137
    … …  
    12151234  } 
    12161235 
    1217   if (MinBadQF > 0.0) {
     1236  if ((MinBadQF > 0.0) && isGPC1chip(measure[0].photcode)) {
     1237    if (!isfinite(measure[0].psfQF)) return FALSE;
    12181238    if (measure[0].psfQF < MinBadQF) return FALSE;
    12191239  }

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

    r37261 r38986  
    22# define J2000 2451545.       /* Julian date at standard epoch */
    33
    4 # if (0)
    5 /* Low precision formulae for the sun, from Almanac p. C24 (1990) */
    6 /* ra and dec are returned as decimal hours and decimal degrees. */
    7 void lpsun (double jd, double *ra, double *dec) {
     4/* Low precision formulae for the sun, from Astro. Almanac p. C5 (2012) */
     5// jdoff is days since J2000
     6int sun_ecliptic (double jdoff, double *lambda, double *beta, double *epsilon, double *Radius) {
    87
    9   double n, L, g, lambda,epsilon,alpha,delta,x,y,z;
    10 
    11   n = jd - J2000;
    12   L = 280.460 + 0.9856474 * n;
    13   g = (357.528 + 0.9856003 * n)/DEG_IN_RADIAN;
    14   lambda = (L + 1.915 * sin(g) + 0.020 * sin(2. * g))/DEG_IN_RADIAN;
    15   epsilon = (23.439 - 0.0000004 * n)/DEG_IN_RADIAN;
    16 
    17   // this is the conversion from ecliptic to celestial coords
    18   x = cos(lambda);
    19   y = cos(epsilon)*sin(lambda);
    20   z = sin(epsilon)*sin(lambda);
    21 
    22   *ra = (atan_circ(x,y))*HRS_IN_RADIAN;
    23   *dec = (asin(z))*DEG_IN_RADIAN;
    24 }
    25 # endif
    26 
    27 # if (0)
    28 /* code borrowed from Skycalc : fix this stuff XXX */
    29 /* Low precision formulae for the sun, from Almanac p. C24 (1990) */
    30 int sun_ecliptic (double jd, double *lambda, double *beta, double *epsilon) {
    31 
    32   double n, L, g;
    33 
    34 
    35   n = jd - J2000;
    36   L = 280.460 + 0.9856474 * n;
    37   g = (357.528 + 0.9856003 * n)*RAD_DEG;
    38   *lambda = L + 1.915 * sin(g) + 0.020 * sin(2. * g); // longitude in degrees
    39   *beta = 0.0;                                    // approx latitude
    40   *epsilon = (23.439 - 0.0000004 * n);            // obliquity of ecliptic in degrees
    41   return TRUE;
    42 }
    43 # endif
    44 
    45 /* Low precision formulae for the sun, from Astro. Almanac p. C5 (2012) */
    46 int sun_ecliptic (double jd, double *lambda, double *beta, double *epsilon, double *Radius) {
    47 
    48   double n = jd - J2000;              // day number
     8  double n = jdoff;           // day number
    499  double L = 280.460 + 0.9856474 * n; // mean solar longitute (corr. for aberration)
    5010  double g = (357.528 + 0.9856003 * n)*RAD_DEG; // Mean anomaly
    … …  
    5818
    5919/* given RA, DEC, Time, calculate the parallax factor */
    60 // Time is relative to Tmean, Tmean is years relative to J2000
    61 int ParFactor (double *pR, double *pD, double RA, double DEC, double Time, double Tmean) {
     20// Time is years since J2000
     21int ParFactor (double *pR, double *pD, double RA, double DEC, double Time) {
    6222
    63   double jd, lambda, beta, epsilon, Radius;
     23  double lambda, beta, epsilon, Radius;
    6424
    65   /* given a Time relative to Tmean, Tmean in years since J2000, determine the solar
    66     longitude S */
     25  /* given a Time in years since J2000, determine the solar longitude S */
    6726
    68   // jd = ohana_sec_to_jd (365.25*86400.0*(Time + Tmean));
    69   jd = 365.25*(Time + Tmean) + J2000;
    70   // fprintf (stderr, "Time: %f, jd: %f\n", Time, jd);
     27  double jdoff = 365.25*Time;
    7128
    72   sun_ecliptic (jd, &lambda, &beta, &epsilon, &Radius);
     29  sun_ecliptic (jdoff, &lambda, &beta, &epsilon, &Radius);
    7330
    7431  double lambda_rad = lambda*RAD_DEG;
    … …  
    9956  return TRUE;
    10057}
     58
     59# if (0)
     60/* Low precision formulae for the sun, from Almanac p. C24 (1990) */
     61/* ra and dec are returned as decimal hours and decimal degrees. */
     62void lpsun (double jd, double *ra, double *dec) {
     63
     64  double n, L, g, lambda,epsilon,alpha,delta,x,y,z;
     65
     66  n = jd - J2000;
     67  L = 280.460 + 0.9856474 * n;
     68  g = (357.528 + 0.9856003 * n)/DEG_IN_RADIAN;
     69  lambda = (L + 1.915 * sin(g) + 0.020 * sin(2. * g))/DEG_IN_RADIAN;
     70  epsilon = (23.439 - 0.0000004 * n)/DEG_IN_RADIAN;
     71
     72  // this is the conversion from ecliptic to celestial coords
     73  x = cos(lambda);
     74  y = cos(epsilon)*sin(lambda);
     75  z = sin(epsilon)*sin(lambda);
     76
     77  *ra = (atan_circ(x,y))*HRS_IN_RADIAN;
     78  *dec = (asin(z))*DEG_IN_RADIAN;
     79}
     80
     81/* code borrowed from Skycalc : fix this stuff XXX */
     82/* Low precision formulae for the sun, from Almanac p. C24 (1990) */
     83int sun_ecliptic (double jd, double *lambda, double *beta, double *epsilon) {
     84
     85  double n, L, g;
     86
     87
     88  n = jd - J2000;
     89  L = 280.460 + 0.9856474 * n;
     90  g = (357.528 + 0.9856003 * n)*RAD_DEG;
     91  *lambda = L + 1.915 * sin(g) + 0.020 * sin(2. * g); // longitude in degrees
     92  *beta = 0.0;                                    // approx latitude
     93  *epsilon = (23.439 - 0.0000004 * n);            // obliquity of ecliptic in degrees
     94  return TRUE;
     95}
     96# endif
     97

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

    r37038 r38986  
    2121  va_end (argp);
    2222
    23   SetProtect (TRUE);
    24   gfits_db_close (db);
    2523  fprintf (stderr, "ERROR: relastro halted\n");
    2624  exit (1);

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

    r37807 r38986  
    163163  }
    164164
    165   if (VERBOSE2) fprintf (stderr, "max deviations for %s using %d pts : %f, %f\n", images[N].name, starmap[N].Npoints, dLmax, dMmax);
     165  if (VERBOSE2) fprintf (stderr, "max deviations for %s using %d pts (%d fitted) : %f, %f\n", images[N].name, starmap[N].Npoints, images[N].nFitAstrom, dLmax, dMmax);
    166166
    167167  if (dLmax > DPOS_MAX) {
    168       if (VERBOSE) fprintf (stderr, "max deviations for %s using %d pts : %f, %f\n", images[N].name, starmap[N].Npoints, dLmax, dMmax);
     168    if (VERBOSE) fprintf (stderr, "max deviations for %s using %d pts (%d fitted) : %f, %f\n", images[N].name, starmap[N].Npoints, images[N].nFitAstrom, dLmax, dMmax);
    169169      return (FALSE);
    170170  }
    171171  if (dMmax > DPOS_MAX) {
    172       if (VERBOSE) fprintf (stderr, "max deviations for %s using %d pts : %f, %f\n", images[N].name, starmap[N].Npoints, dLmax, dMmax);
     172      if (VERBOSE) fprintf (stderr, "max deviations for %s using %d pts (%d fitted) : %f, %f\n", images[N].name, starmap[N].Npoints, images[N].nFitAstrom, dLmax, dMmax);
    173173      return (FALSE);
    174174  }

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

    r38062 r38986  
    2929// update astrometry of all chips relative to the average positions
    3030// if NTHREADS is non-zero, call the threaded version of this function
    31 int UpdateChips (Catalog *catalog, int Ncatalog) {
     31int UpdateChips (Catalog *catalog, int Ncatalog, int Nloop) {
    3232
    3333  off_t Nskip, Nmosaic, NnewFit, NoldFit;
    … …  
    4040  char *mode;
    4141
     42  AstromErrorSetLoop (Nloop, TRUE);
     43
    4244  if (NTHREADS) {
    4345    UpdateChips_threaded (catalog, Ncatalog);
    … …  
    5759  // each chip is fitted independently, so we could do N at once in parallel
    5860  for (i = 0; i < Nimage; i++) {
     61
     62    VERBOSE_IMAGE = !strcmp(image[i].name, "o5745g0516o.356887.cm.982631.smf[XY54]");
    5963
    6064    // XXX looks like everything below is thread safe : we can unroll this into a set of
    … …  
    9195    }
    9296
     97    if (VERBOSE_IMAGE) {
     98      dump_stardata_pts (raw, Nraw, "testimage.raw.dat");
     99      dump_stardata_pts (ref, Nref, "testimage.ref.dat");
     100      fprintf (stderr, "dumped test image\n");
     101    }
     102
    93103    // note that Nraw & Nref must be equal: if not, we made a programming error in one of these two functions.
    94104    assert (Nraw == Nref);
    … …  
    105115    // fprintf (stderr, "image "OFF_T_FMT" : Nstars: "OFF_T_FMT"\n",  i,  Nraw);
    106116    if (!FitChip (raw, ref, Nraw, &image[i])) {
    107       if (VERBOSE) fprintf (stderr, "reject fit for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT" of %d\n", image[i].name,  i,  Nraw, image[i].nstar);
     117      if (VERBOSE) fprintf (stderr, "reject fit for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT", Nused %d of %d\n", image[i].name,  i,  Nraw, image[i].nFitAstrom, image[i].nstar);
    108118
    109119      if (1) {
    … …  
    124134
    125135    if (!checkStarMap (i)) {
    126       if (VERBOSE) fprintf (stderr, "fit diverges too much for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT"\n", image[i].name,  i,  Nraw);
     136      if (VERBOSE) fprintf (stderr, "fit diverges too much for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT", Nused: %d\n", image[i].name,  i,  Nraw, image[i].nFitAstrom);
    127137
    128138      if (1) {
    … …  
    148158    setImageRaw (catalog, Ncatalog, i, raw, Nraw, MODE_MOSAIC);
    149159    if (USE_GALAXY_MODEL) {
     160      // XXX DEPRECATE?
    150161      image[i].flags |= ID_IMAGE_ASTROM_GMM;
    151162    }
    … …  
    311322    // fprintf (stderr, "image "OFF_T_FMT" : Nstars: "OFF_T_FMT"\n",  i,  Nraw);
    312323    if (!FitChip (raw, ref, Nraw, &image[i])) {
    313       if (VERBOSE) fprintf (stderr, "reject fit for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT" of %d\n", image[i].name,  i,  Nraw, image[i].nstar);
     324      if (VERBOSE) fprintf (stderr, "reject fit for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT", Nused %d of %d\n", image[i].name,  i,  Nraw, image[i].nFitAstrom, image[i].nstar);
    314325
    315326      // restore status quo ante (replace truMap with tmpMap)
    … …  
    328339
    329340    if (!checkStarMap (i)) {
    330       if (VERBOSE) fprintf (stderr, "fit diverges too much for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT"\n", image[i].name,  i,  Nraw);
     341      if (VERBOSE) fprintf (stderr, "fit diverges too much for image %s ("OFF_T_FMT") : Nstars: "OFF_T_FMT", Nused: %d\n", image[i].name,  i,  Nraw, image[i].nFitAstrom);
    331342
    332343      // restore status quo ante (replace truMap with tmpMap)

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

    r38471 r38986  
    9797  }   
    9898
    99 # if (0)
     99# if (1)
    100100 
    101101  UpdateObjectOffsets_parallel_table (table, sky);
    … …  
    155155
    156156    char *command = NULL;
    157     strextend (&command, "relastro_client -update-offsets -hostID %d -D CATDIR %s -hostdir %s -region %f %f %f %f -statmode %s -minerror %f",
    158               group->hosts[i][0].hostID, CATDIR, group->hosts[i][0].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE, MIN_ERROR);
     157    strextend (&command, "relastro_client -update-offsets");
     158    strextend (&command, "-hostID %d", group->hosts[i][0].hostID);
     159    strextend (&command, "-D CATDIR %s", CATDIR);
     160    strextend (&command, "-hostdir %s", group->hosts[i][0].pathname);
     161    strextend (&command, "-region %f %f %f %f", UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
     162    strextend (&command, "-statmode %s", STATMODE);
     163    strextend (&command, "-minerror %f", MIN_ERROR);
    159164
    160165    if (FIT_MODE == FIT_PM_ONLY)         strextend (&command, "-pm");
    … …  
    176181    if (ExcludeBogus)    strextend (&command, "-exclude-bogus %f", ExcludeBogusRadius);
    177182   
     183    if (USE_ALL_IMAGES)      strextend (&command, "-use-all-images");
    178184    if (USE_FIXED_PIXCOORDS) strextend (&command, "-D USE_FIXED_PIXCOORDS 1");
    179185
    … …  
    184190    if (PhotFlagPoor)       strextend (&command, "+photflagpoor %d", PhotFlagPoor);
    185191    // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values
     192
     193    if (N_BOOTSTRAP_SAMPLES > 1) strextend (&command, "-bootstrap-samples %d", N_BOOTSTRAP_SAMPLES);
    186194
    187195    if (DCR_BLUE_COLOR_POS && DCR_BLUE_COLOR_NEG) {
    … …  
    303311    // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values
    304312
     313    if (N_BOOTSTRAP_SAMPLES > 1) strextend (&command, "-bootstrap-samples %d", N_BOOTSTRAP_SAMPLES);
     314
    305315    if (DCR_BLUE_COLOR_POS && DCR_BLUE_COLOR_NEG) {
    306316      strextend (&command, "-dcr-blue-color %s %s", DCR_BLUE_COLOR_POS, DCR_BLUE_COLOR_NEG);

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

    r37807 r38986  
    22# define PAR_TOOFEW 5
    33
    4 int UpdateObjects_Chips (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats, int i, off_t m, int applyGalaxyOffset);
    5 int UpdateObjects_Stack (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats);
    6 
    7 static off_t Nmax;
    8 static double *X, *dX;
    9 static double *Y, *dY;
    10 static double *R, *dR;
    11 static double *D, *dD;
    12 static double *pX;
    13 static double *pY;
    14 static double *T;
    15 static double *dT;
    16 static double *C_blue;
    17 static double *C_red;
    18 
    19 static Coords coords;
    20 
    21 static time_t T2000;
    22 
    23 void initFitStats (FitStats *fitStats) {
    24   fitStats->Nave = 0; 
    25   fitStats->Npm = 0;   
    26   fitStats->Npar = 0; 
    27   fitStats->Nskip = 0;
    28   fitStats->Noffset = 0;
    29   return;
    30 }
    31 
    32 void sumFitStats (FitStats *srcFitStats, FitStats *tgtFitStats) {
    33   tgtFitStats->Nave    += srcFitStats->Nave    ; 
    34   tgtFitStats->Npm     += srcFitStats->Npm     ;   
    35   tgtFitStats->Npar    += srcFitStats->Npar    ; 
    36   tgtFitStats->Nskip   += srcFitStats->Nskip   ;
    37   tgtFitStats->Noffset += srcFitStats->Noffset ;
    38   return;
    39 }
    40 
    41 void initObjectData (Catalog *catalog, int Ncatalog) {
    42 
    43   off_t i, j;
    44  
    45   Nmax = 0;
    46   for (i = 0; i < Ncatalog; i++) {
    47     for (j = 0; j < catalog[i].Naverage; j++) {
    48       Nmax = MAX (Nmax, catalog[i].average[j].Nmeasure);
    49     }
    50   }
    51 
    52   ALLOCATE (R, double, MAX (1, Nmax));
    53   ALLOCATE (D, double, MAX (1, Nmax));
    54   ALLOCATE (T, double, MAX (1, Nmax));
    55   ALLOCATE (X, double, MAX (1, Nmax));
    56   ALLOCATE (Y, double, MAX (1, Nmax));
    57 
    58   ALLOCATE (dR, double, MAX (1, Nmax));
    59   ALLOCATE (dD, double, MAX (1, Nmax));
    60   ALLOCATE (dT, double, MAX (1, Nmax));
    61   ALLOCATE (dX, double, MAX (1, Nmax));
    62   ALLOCATE (dY, double, MAX (1, Nmax));
    63 
    64   ALLOCATE (pX, double, MAX (1, Nmax));
    65   ALLOCATE (pY, double, MAX (1, Nmax));
    66 
    67   ALLOCATE (C_blue, double, MAX (1, Nmax));
    68   ALLOCATE (C_red,  double, MAX (1, Nmax));
    69 
    70   /* project coordinates to a plane centered on the object with units of arcsec */
    71   InitCoords (&coords, "DEC--SIN");
    72   coords.cdelt1 = coords.cdelt2 = 1.0 / 3600.0;
    73 
    74   // use J2000 as a reference time
    75   T2000 = ohana_date_to_sec ("2000/01/01,12:00:00");
    76 } 
    77 
    78 void freeObjectData () {
    79 
    80   free (R);
    81   free (D);
    82   free (T);
    83   free (X);
    84   free (Y);
    85 
    86   free (dR);
    87   free (dD);
    88   free (dT);
    89   free (dX);
    90   free (dY);
    91 
    92   free (pX);
    93   free (pY);
    94 
    95   free (C_blue);
    96   free (C_red);
    97 } 
     4int DumpObjectsWith2MASS (Catalog *catalog, int Ncatalog);
    985
    996// This function operates on both Measure and MeasureTiny.  In the big stages, this should
    1007// be called with just MeasureTiny set and Measure == NULL
    1018int UpdateObjects (Catalog *catalog, int Ncatalog, int Nloop) {
    102 
    103   initObjectData (catalog, Ncatalog);
    1049
    10510  // XXX in the future, use catalog[0].Nsecfilt only?  allow catalogs to have variable Nsecfilt?
    … …  
    10914  }
    11015
    111   FitStats sumStatsChips; initFitStats (&sumStatsChips);
    112   FitStats sumStatsStack; initFitStats (&sumStatsStack);
     16  int NmeasureMax = CatalogMaxNmeasure (catalog, Ncatalog);
     17
     18  // allocate summary stats with Nmax = 0, Nboot = 0
     19  FitStats *sumStatsChips = FitStatsInit (0, 0);
     20  FitStats *sumStatsStack = FitStatsInit (0, 0);
     21
     22  FitStats *fitStatsChips = FitStatsInit (NmeasureMax, N_BOOTSTRAP_SAMPLES);
     23  FitStats *fitStatsStack = FitStatsInit (NmeasureMax, N_BOOTSTRAP_SAMPLES);
     24
     25  AstromErrorSetLoop (Nloop, FALSE);
    11326
    11427  int i;
    … …  
    11730    if (VERBOSE2) fprintf (stderr, "astrometrize catalog %d : "OFF_T_FMT" ave, "OFF_T_FMT" meas\n", i,  catalog[i].Naverage,  catalog[i].Nmeasure);
    11831
    119     FitStats fitStatsChips; initFitStats (&fitStatsChips);
    120     FitStats fitStatsStack; initFitStats (&fitStatsStack);
     32    FitStatsReset (fitStatsChips);
     33    FitStatsReset (fitStatsStack);
    12134
    12235    off_t j;
    … …  
    12942      SecFilt *secfilt = &catalog[i].secfilt[j*Nsecfilt];
    13043
    131       UpdateObjects_Stack(average, secfilt, measure, measureBig, Nsecfilt, &fitStatsStack);
    132       UpdateObjects_Chips(average, secfilt, measure, measureBig, Nsecfilt, &fitStatsChips, i, m, Nloop);
    133     }
    134     if (VERBOSE2) fprintf (stderr, "catalog %d : chips "OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par : Nskip "OFF_T_FMT", Noffset "OFF_T_FMT"\n",  i,  fitStatsChips.Nave,  fitStatsChips.Npm,  fitStatsChips.Npar,  fitStatsChips.Nskip, fitStatsChips.Noffset);
    135     if (VERBOSE2) fprintf (stderr, "catalog %d : stack "OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par : Nskip "OFF_T_FMT", Noffset "OFF_T_FMT"\n",  i,  fitStatsStack.Nave,  fitStatsStack.Npm,  fitStatsStack.Npar,  fitStatsStack.Nskip, fitStatsStack.Noffset);
    136     sumFitStats (&fitStatsChips, &sumStatsChips);
    137     sumFitStats (&fitStatsStack, &sumStatsStack);
    138   }
    139   freeObjectData ();
    140 
    141   if (VERBOSE && (Ncatalog > 1)) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n",  (sumStatsChips.Nave + sumStatsChips.Npm + sumStatsChips.Npar),  sumStatsChips.Nave,  sumStatsChips.Npm,  sumStatsChips.Npar,  sumStatsChips.Nskip, sumStatsChips.Noffset);
    142   if (VERBOSE && (Ncatalog > 1)) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n",  (sumStatsStack.Nave + sumStatsStack.Npm + sumStatsStack.Npar),  sumStatsStack.Nave,  sumStatsStack.Npm,  sumStatsStack.Npar,  sumStatsStack.Nskip, sumStatsStack.Noffset);
     44      UpdateObjects_Stack(average, secfilt, measure, measureBig, Nsecfilt, fitStatsStack);
     45      UpdateObjects_Chips(average, secfilt, measure, measureBig, Nsecfilt, fitStatsChips, i, m);
     46    }
     47    if (VERBOSE2) fprintf (stderr, "catalog %d : chips "OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par : Nskip "OFF_T_FMT", Noffset "OFF_T_FMT"\n",  i,  fitStatsChips->Nave,  fitStatsChips->Npm,  fitStatsChips->Npar,  fitStatsChips->Nskip, fitStatsChips->Noffset);
     48    if (VERBOSE2) fprintf (stderr, "catalog %d : stack "OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par : Nskip "OFF_T_FMT", Noffset "OFF_T_FMT"\n",  i,  fitStatsStack->Nave,  fitStatsStack->Npm,  fitStatsStack->Npar,  fitStatsStack->Nskip, fitStatsStack->Noffset);
     49    FitStatsSum (fitStatsChips, sumStatsChips);
     50    FitStatsSum (fitStatsStack, sumStatsStack);
     51  }
     52
     53  // DumpObjectsWith2MASS (catalog, Ncatalog);
     54
     55  FitStatsFree (fitStatsChips);
     56  FitStatsFree (fitStatsStack);
     57
     58  if (VERBOSE && (Ncatalog > 1)) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n",  (sumStatsChips->Nave + sumStatsChips->Npm + sumStatsChips->Npar),  sumStatsChips->Nave,  sumStatsChips->Npm,  sumStatsChips->Npar,  sumStatsChips->Nskip, sumStatsChips->Noffset);
     59  if (VERBOSE && (Ncatalog > 1)) fprintf (stderr, "fitted "OFF_T_FMT" objects ("OFF_T_FMT" ave, "OFF_T_FMT" pm, "OFF_T_FMT" par), skipped "OFF_T_FMT", "OFF_T_FMT" have too large an offset\n",  (sumStatsStack->Nave + sumStatsStack->Npm + sumStatsStack->Npar),  sumStatsStack->Nave,  sumStatsStack->Npm,  sumStatsStack->Npar,  sumStatsStack->Nskip, sumStatsStack->Noffset);
     60
     61  FitStatsFree (sumStatsChips);
     62  FitStatsFree (sumStatsStack);
     63
    14364  return (TRUE);
    14465}
    … …  
    14667// This function operates on both Measure and MeasureTiny.  In the big stages, this should
    14768// be called with just MeasureTiny set and Measure == NULL
    148 int UpdateObjects_Chips (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats, int i, off_t m, int applyGalaxyOffset) {
    149 
    150   int setRefColor = areImagesMatched();
     69int DumpObjectsWith2MASS (Catalog *catalog, int Ncatalog) {
     70
     71  int i;
     72  for (i = 0; i < Ncatalog; i++) {
     73    off_t j;
     74    for (j = 0; j < catalog[i].Naverage; j++) {
     75      /* calculate the average value of R,D for a single star */
     76      off_t m = catalog[i].average[j].measureOffset;
     77
     78      off_t k;
     79      for (k = 0; k < catalog[i].average[j].Nmeasure; k++) {
     80        MeasureTiny *measure = &catalog[i].measureT[m+k];
     81        if (measure->dbFlags & ID_MEAS_OBJECT_HAS_2MASS) {
     82          fprintf (stderr, "0x%08x 0x%08x : %12.8f %12.8f %5d\n", catalog[i].average[j].objID, catalog[i].average[j].catID, measure->R, measure->D, measure->photcode);
     83        }
     84      }
     85    }
     86  }
     87  return (TRUE);
     88}
     89
     90// This function operates on both Measure and MeasureTiny.  In the big stages, this should
     91// be called with just MeasureTiny set and Measure == NULL
     92int UpdateObjects_Chips (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats, int cat, off_t measOff) {
     93
     94  int k;
    15195
    15296  /* calculate the average value of R,D for a single star */
    15397
    154   PMFit fit;    memset (&fit,    0, sizeof(fit));
    155   PMFit fitAve; memset (&fitAve, 0, sizeof(fitAve)); fitAve.chisq = NAN;
    156   PMFit fitPM;  memset (&fitPM,  0, sizeof(fitPM));  fitPM.chisq = NAN;
    157   PMFit fitPAR; memset (&fitPAR, 0, sizeof(fitPAR)); fitPAR.chisq = NAN;
     98  FitAstromResult fitPos, fitPM, fitPar;
     99  FitAstromResultInit (&fitPos);
     100  FitAstromResultInit (&fitPM);
     101  FitAstromResultInit (&fitPar);
    158102
    159103  // if we fail to fit the astrometry for some reason, we need to set/reset these
    … …  
    167111  if (average[0].Nmeasure == 0) return TRUE;
    168112
    169   int NcBlue = 0;
    170   int NcRed = 0;
    171   int N = 0;
    172 
    173113  int mode = FIT_MODE; // start with the globally-defined fit mode
    174114
    … …  
    177117  XVERB |= (average[0].objID == OBJ_ID_DST) && (average[0].catID == CAT_ID_DST);
    178118
    179   // find the basic properties of the detections for this object (Tmin, Tmax, Tmean)
    180   off_t k;
    181   for (k = 0; k < average[0].Nmeasure; k++) {
    182 
    183     if (XVERB) {
    184       char *date = ohana_sec_to_date (measure[k].t);
    185       int dbFlagsBig = measureBig ? measureBig[k].dbFlags : 0;
    186       fprintf (stderr, OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n",  k, measure[k].R, measure[k].D, date, measure[k].dbFlags, dbFlagsBig);
    187       free (date);
    188     }
    189 
    190     // SKIP gpc1 stack data
    191     if (isGPC1stack(measure[k].photcode)) continue;
    192 
    193     // SKIP gpc1 forced-warp data
    194     if (isGPC1warp(measure[k].photcode)) continue;
    195 
    196     // reset the bit to note that a detection was used (or not)
    197     measure[k].dbFlags &= ~ID_MEAS_USED_OBJ;
    198     if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; }
    199 
    200     // does the measurement pass the supplied filtering constraints?
    201     // MeasFilterTestTiny does not test psfQF
    202     // exclude bad detections based on: photcodes, psfQF, time range, photflags & astromBadMask, mag_inst
    203     int keepMeasure = measureBig ? MeasFilterTest(&measureBig[k], FALSE) : MeasFilterTestTiny(&measure[k], FALSE);
    204     if (!keepMeasure) {
    205       continue;
    206     }
    207 
    208     double Ri = getMeanR (&measure[k], average, secfilt);
    209     double Di = getMeanD (&measure[k], average, secfilt);
    210 
    211     // if we are correcting for the Galaxy Motion Model, only should apply it here
    212     // (a) when we are working to correct the images (mean R,D assumed to be at J2000) and
    213     // (b) if we think the measure R,D is already at the image epoch position
    214     if (USE_GALAXY_MODEL && applyGalaxyOffset) {
    215       Ri -= measure[k].RoffGAL / 3600.0;
    216       Di -= measure[k].DoffGAL / 3600.0;
    217     }
    218 
    219     // XXX add in dR,dD GAL here
    220 
    221     // mark (as POOR) any measurements which are deviant from the mean by > ExcludeBogusRadius
    222     if (ExcludeBogus) {
    223       coords.crval1 = average[0].R;
    224       coords.crval2 = average[0].D;
    225       double Xi, Yi;
    226       RD_to_XY (&Xi, &Yi, Ri, Di, &coords);
    227       double radius = hypot(Xi, Yi);
    228       if (radius > ExcludeBogusRadius) {
    229         measure[k].dbFlags |= ID_MEAS_POOR_ASTROM;
    230         if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_POOR_ASTROM; }
    231         continue;
    232       }
    233       measure[k].dbFlags &= ~ID_MEAS_POOR_ASTROM;
    234       if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_POOR_ASTROM; }
    235     }
    236 
    237     // outlier rejection
    238     if (FALSE && FlagOutlier && (measure[k].dbFlags & ID_MEAS_POOR_ASTROM)) {
    239       continue;
    240     }
    241 
    242     R[N] = Ri;
    243     D[N] = Di;
    244 
    245     // measure[k].t is UNIX seconds, T2000 is UNIX seconds for J2000.
    246     // T[] is time in years since J2000 (jd = 2451545)
    247     T[N] = (measure[k].t - T2000) / (86400*365.25) ; // time relative to J2000 in years
    248 
    249     // dX, dY : error in arcsec --
    250     dX[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_RA);
    251     dY[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_DEC);
    252 
    253     // allow a given photcode or measurement to be
    254     // ignored if the error is NAN (for photcode, set astromErrSys to NaN)
    255     if (isnan(dX[N])) continue;
    256     if (isnan(dY[N])) continue;
    257 
    258     // add systematic error in quadrature, if desired
    259     // only do this after the fit has converged (or you will never improve the poor images)
    260     // if (INCLUDE_SYS_ERR) {
    261     // float dRsys = FromShortPixels(measure[k].dRsys);
    262     // dX[N] = hypot(dX[N], dRsys);
    263     // dY[N] = hypot(dY[N], dRsys);
    264     // }
    265 
    266     // dX[N] = 0.1;
    267     // dY[N] = 0.1;
    268 
    269     dT[N] = measure[k].dt;
    270 
    271     // XXX this is (slightly) inconsistent: dX,dY are the X and Y direction errors in
    272     // arcseconds.  dR, dD are the errors in those directions in degrees.  IF we have
    273     // non-circular errors (different values for X and Y), then dR and dD will be
    274     // incorrect: they would need to be rotated to take out the position angle
    275     dR[N] = dX[N] / 3600.0;
    276     dD[N] = dY[N] / 3600.0;
    277 
    278     if (setRefColor) {
    279       float colorBlue = getColorBlue (m+k, i);
    280       if (!isnan(colorBlue)) {
    281         C_blue[NcBlue] = colorBlue;
    282         NcBlue++;
    283       }
    284       float colorRed = getColorRed (m+k, i);
    285       if (!isnan(colorRed)) {
    286         C_red[NcRed] = colorRed;
    287         NcRed++;
    288       }
    289     }
    290 
    291     measure[k].dbFlags |= ID_MEAS_USED_OBJ;
    292     if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_USED_OBJ; }
    293 
    294     N++;
    295   } // loop over measurements : average[0].Nmeasure
    296 
    297   if (N < 1) {
     119  // select the measurements to be used in this analysis
     120  UpdateObjects_SelectMeasures (fitStats, average, secfilt, measure, measureBig, FALSE);
     121
     122  // if there are no exposure detections, use the stack position
     123  if (fitStats->Npoints < 1) {
    298124    if (isfinite(average[0].Rstk) && isfinite(average[0].Dstk)) {
    299125      average[0].R  = average[0].Rstk;
    … …  
    301127      average[0].dR = average[0].dRstk;
    302128      average[0].dD = average[0].dDstk;
     129      average[0].flags |= ID_STACK_ASTROM;
    303130    }
    304131    return FALSE;
    305132  }
    306133
    307   // if we have too few good detections for the desired fit, or too limited a
    308   // baseline, use a fit with fewer parameters.  XXX if we have too few measurements
    309   // for even the average position, consider including the lower-quality detections?
    310 
    311   // find Tmin & Tmax from the list of accepted measurements
    312   double Tmean = 0.0;
    313   double Tmin = T[0];
    314   double Tmax = T[0];
    315   for (k = 0; k < N; k++) {
    316     Tmin = MIN(Tmin, T[k]);
    317     Tmax = MAX(Tmax, T[k]);
    318     Tmean += T[k];
    319   }
    320   double Trange = Tmax - Tmin;
    321 
    322   if (RELASTRO_OP == OP_HIGH_SPEED) {
    323     Tmean = 0.5*(Tmax - Tmin);
    324   } else {
    325     Tmean /= (float) N;
    326   }
    327 
    328   /* we need to do the fit in a locally linear space; choose a ref coordinate */
    329   coords.crval1 = R[0];
    330   coords.crval2 = D[0];
     134  double Tmean, Trange, parRange;
     135  FitAstromPoints_Project (fitStats, &Tmean, &Trange, &parRange);
    331136
    332137  // to judge the quality of the PM and PAR fits, we need to fit all three models and compare Chisq
    333138
    334   // project all of the R,D coordinates to a plane centered on this coordinate. set
    335   // the times to be relative to Tmean (this is required for parallax as well)
    336   for (k = 0; k < N; k++) {
    337     RD_to_XY (&X[k], &Y[k], R[k], D[k], &coords);
    338     T[k] -= Tmean;
    339     if (XVERB) {
    340       fprintf (stderr, OFF_T_FMT" %f %f %f  %f %f +/- %f %f\n",  k, T[k], R[k], D[k], X[k], Y[k], dX[k], dY[k]);
    341     }
    342   }       
     139  // if we have too few good detections for the desired fit, or too limited a baseline,
     140  // use a fit with fewer parameters.
    343141
    344142  // *** first fit for the proper motion (skip fit if Trange or Npts is too small) ***
    … …  
    346144    if (Trange < PM_DT_MIN) {
    347145      mode = FIT_AVERAGE;
    348       goto skipPM;
    349     }
    350     if (N <= PM_TOOFEW) {
     146      goto justPosition;
     147    }
     148    if (fitStats->Npoints <= PM_TOOFEW) {
    351149      mode = FIT_AVERAGE;
    352       goto skipPM;
    353     }
    354 
    355     FitPM (&fitPM, X, dX, Y, dY, T, N, XVERB);
    356 
    357     if (XVERB) fprintf (stderr, "fitted PM:  %f - %f : %f %f : %f %f : %f vs %f\n", Tmin, Tmax, fitPM.Ro, fitPM.Do, fitPM.uR, fitPM.uD, fitPM.chisq, fitAve.chisq);
     150      goto justPosition;
     151    }
     152
     153    if (fitStats->NfitAlloc == 1) {
     154      // if N_BOOTSTRAP_SAMPLES = 1, no bootstrap resampling:
     155      FitPM (&fitPM, fitStats->fitdataPM, fitStats->points, fitStats->Npoints);
     156    } else {
     157      fitStats->Nfit = 0;
     158      for (k = 0; k < fitStats->NfitAlloc; k++) {
     159        BootstrapResample (fitStats->sample, fitStats->points, fitStats->Npoints);
     160        if (!FitPM (&fitStats->fit[k], fitStats->fitdataPM, fitStats->sample, fitStats->Npoints)) continue;
     161        fitStats->Nfit ++;
     162      }
     163      BootstrapRobustStats (&fitPM, fitStats->fit, fitStats->Nfit, FIT_RESULT_RA);
     164      BootstrapRobustStats (&fitPM, fitStats->fit, fitStats->Nfit, FIT_RESULT_DEC);
     165      BootstrapRobustStats (&fitPM, fitStats->fit, fitStats->Nfit, FIT_RESULT_uR);
     166      BootstrapRobustStats (&fitPM, fitStats->fit, fitStats->Nfit, FIT_RESULT_uD);
     167    }
     168    FitAstromSetChisq (&fitPM, fitStats->points, fitStats->Npoints, FIT_PM_ONLY);
    358169
    359170    // project Ro, Do back to RA,DEC
    360     XY_to_RD (&fitPM.Ro, &fitPM.Do, fitPM.Ro, fitPM.Do, &coords);
    361     if (XVERB) fprintf (stderr, "project: %f %f : %f %f : %f\n", fitPM.Ro, fitPM.Do, fitPM.uR, fitPM.uD, fitPM.p);
     171    XY_to_RD (&fitPM.Ro, &fitPM.Do, fitPM.Ro, fitPM.Do, &fitStats->coords);
    362172    if (fabs(fitPM.Ro) < 0.01) fprintf (stderr, "watch out for 0,360 boundary\n");
    363     // XXX : does this make sense at 0,360 boundary?
    364173
    365174    fitPM.p  = fitPM.dp  = 0.0;
    … …  
    374183  }
    375184 
    376 skipPM:
    377185  // fit the parallax + proper-motion model
    378186  // NOTE : we only fit PAR if we have already fitted for proper motion. if we do not fit PM or we fail
    379187  // to fit PM, we do not attempt PAR.  thus failure to fit PAR falls back to PM-only
    380188  if (mode == FIT_PM_AND_PAR) {
    381     if (Trange < PM_DT_MIN) {
    382       mode = FIT_PM_ONLY;
    383       goto skipPAR;
    384     }
    385     if (N <= PAR_TOOFEW) {
    386       mode = FIT_PM_ONLY;
    387       goto skipPAR;
    388     }
    389     float pXmin = +2.0;
    390     float pXmax = -2.0;
    391     float pYmin = +2.0;
    392     float pYmax = -2.0;
    393     for (k = 0; k < N; k++) {
    394       ParFactor (&pX[k], &pY[k], R[k], D[k], T[k], Tmean);
    395       pXmin = MIN (pXmin, pX[k]);
    396       pXmax = MAX (pXmax, pX[k]);
    397       pYmin = MIN (pYmin, pY[k]);
    398       pYmax = MAX (pYmax, pY[k]);
    399     }
    400     float dXRange = pXmax - pXmin;
    401     float dYRange = pYmax - pYmin;
    402     float parRange = hypot (dXRange, dYRange);
    403        
    404189    if (parRange < PAR_FACTOR_MIN) {
    405190      mode = FIT_PM_ONLY;
    406       goto skipPAR;
    407     }
    408 
    409     FitPMandPar (&fitPAR, X, dX, Y, dY, T, pX, pY, N, XVERB);
    410     if (XVERB) fprintf (stderr, "fitted PM+PAR:  %f - %f : %f %f : %f %f : %f %f : %f vs %f vs %f\n", Tmin, Tmax, fitPAR.Ro, fitPAR.Do, fitPAR.uR, fitPAR.uD, fitPAR.p, fitPAR.dp, fitPAR.chisq, fitPM.chisq, fitAve.chisq);
    411 
    412     XY_to_RD (&fitPAR.Ro, &fitPAR.Do, fitPAR.Ro, fitPAR.Do, &coords);
     191      goto justPosition;
     192    }
     193    if (fitStats->Npoints <= PAR_TOOFEW) {
     194      mode = FIT_PM_ONLY;
     195      goto justPosition;
     196    }
     197
     198    if (fitStats->NfitAlloc == 1) {
     199      // if N_BOOTSTRAP_SAMPLES = 1, no bootstrap resampling:
     200      FitPMandPar (&fitPar, fitStats->fitdataPar, fitStats->points, fitStats->Npoints);
     201    } else {
     202      fitStats->Nfit = 0;
     203      for (k = 0; k < fitStats->NfitAlloc; k++) {
     204        BootstrapResample (fitStats->sample, fitStats->points, fitStats->Npoints);
     205        FitPMandPar (&fitStats->fit[k], fitStats->fitdataPar, fitStats->sample, fitStats->Npoints);
     206        fitStats->Nfit ++;
     207      }
     208      BootstrapRobustStats (&fitPar, fitStats->fit, fitStats->Nfit, FIT_RESULT_RA);
     209      BootstrapRobustStats (&fitPar, fitStats->fit, fitStats->Nfit, FIT_RESULT_DEC);
     210      BootstrapRobustStats (&fitPar, fitStats->fit, fitStats->Nfit, FIT_RESULT_uR);
     211      BootstrapRobustStats (&fitPar, fitStats->fit, fitStats->Nfit, FIT_RESULT_uD);
     212      BootstrapRobustStats (&fitPar, fitStats->fit, fitStats->Nfit, FIT_RESULT_PLX);
     213    }
     214    FitAstromSetChisq (&fitPar, fitStats->points, fitStats->Npoints, FIT_PM_AND_PAR);
     215
     216    // project Ro, Do back to RA,DEC
     217    XY_to_RD (&fitPar.Ro, &fitPar.Do, fitPar.Ro, fitPar.Do, &fitStats->coords);
     218    if (fabs(fitPar.Ro) < 0.01) fprintf (stderr, "watch out for 0,360 boundary\n");
     219
    413220    average[0].flags |= ID_STAR_FIT_PAR;
    414221    fitStats->Npar ++;
    415222
    416     if (fabs(fitPM.Ro) < 0.01) fprintf (stderr, "watch out for 0,360 boundary\n");
    417 
    418223    // XXX a hard-wired hack...
    419     if ((fabs(fitPAR.uR) > 2.0) || (fabs(fitPAR.uD) > 2.0)) {
     224    if ((fabs(fitPar.uR) > 2.0) || (fabs(fitPar.uD) > 2.0)) {
    420225      mode = FIT_PM_ONLY;
    421226    }
    422227  }       
    423228
    424 skipPAR:
     229justPosition:
    425230  {
    426     // ALWAYS fit the average model
    427     StatType statsR, statsD;
    428     liststats_pos (X, dX, N, &statsR, XVERB); // WARNING: this function modifies R (do not use after here)
    429     liststats_pos (Y, dY, N, &statsD, XVERB); // WARNING: this function modifies D (do not use after here)
     231    // use bootstrap resampling to check the error distribution
     232    // if we only have one point, this is silly...
     233   
     234    if (fitStats->NfitAlloc == 1) {
     235      FitAstromResultSetPM (&fitPos, 1, average);
     236      FitPosPMfixed (&fitPos, fitStats->fitdataPos, fitStats->points, fitStats->Npoints);
     237    } else {
     238      fitStats->Nfit = 0;
     239      FitAstromResultSetPM (fitStats->fit, fitStats->NfitAlloc, average);
     240      for (k = 0; k < fitStats->NfitAlloc; k++) {
     241        BootstrapResample (fitStats->sample, fitStats->points, fitStats->Npoints);
     242        FitPosPMfixed (&fitStats->fit[k], fitStats->fitdataPos, fitStats->sample, fitStats->Npoints);
     243        fitStats->Nfit ++;
     244      }
     245      BootstrapRobustStats (&fitPos, fitStats->fit, fitStats->Nfit, FIT_RESULT_RA);
     246      BootstrapRobustStats (&fitPos, fitStats->fit, fitStats->Nfit, FIT_RESULT_DEC);
     247    }
     248    FitAstromSetChisq (&fitPos, fitStats->points, fitStats->Npoints, FIT_AVERAGE);
    430249
    431250    // project Ro, Do back to RA,DEC
    432     XY_to_RD (&fitAve.Ro, &fitAve.Do, statsR.mean, statsD.mean, &coords);
    433     if (XVERB) fprintf (stderr, "average: %f %f\n", fitAve.Ro, fitAve.Do);
    434 
    435     fitAve.dRo = statsR.sigma;
    436     fitAve.dDo = statsD.sigma;
    437 
    438     fitAve.chisq = (N > 1) ? 0.5 * (statsR.chisq + statsD.chisq) : NAN;
    439     fitAve.Nfit = N;
    440 
    441     fitAve.uR = fitAve.duR = 0.0;
    442     fitAve.uD = fitAve.duD = 0.0;
    443     fitAve.p  = fitAve.dp  = 0.0;
     251    XY_to_RD (&fitPos.Ro, &fitPos.Do, fitPos.Ro, fitPos.Do, &fitStats->coords);
    444252    average[0].flags |= ID_STAR_FIT_AVE;
    445253    fitStats->Nave ++;
    446254  }
    447255
     256  // update the bit flags of which points were used
     257  for (k = 0; k < fitStats->Npoints; k++) {
     258    int Nm = fitStats->points[k].measure;
     259    myAssert (Nm >= 0, "oops");
     260    measure[Nm].dbFlags |= ID_MEAS_USED_OBJ;
     261    if (measureBig) { measureBig[Nm].dbFlags |= ID_MEAS_USED_OBJ; }
     262  }
     263
     264  // we can set the star reference-image color only if we have loaded the image data
     265  int setRefColor = areImagesMatched();
    448266  if (setRefColor) {
     267    float *C_blue = NULL;
     268    float *C_red = NULL;
     269    ALLOCATE (C_blue, float, fitStats->Npoints);
     270    ALLOCATE (C_red, float, fitStats->Npoints);
     271
     272    int NcBlue = 0;
     273    int NcRed = 0;
     274
     275    for (k = 0; k < fitStats->Npoints; k++) {
     276      int Nm = fitStats->points[k].measure;
     277      float colorBlue = getColorBlue (measOff + Nm, cat);
     278      if (!isnan(colorBlue)) {
     279        C_blue[NcBlue] = colorBlue;
     280        NcBlue++;
     281      }
     282      float colorRed = getColorRed (measOff + Nm, cat);
     283      if (!isnan(colorRed)) {
     284        C_red[NcRed] = colorRed;
     285        NcRed++;
     286      }
     287    }
     288
     289    // need to reassign here if isfinite()
    449290    float colorMedian;
    450     dsort (C_blue, NcBlue);
     291    fsort (C_blue, NcBlue);
    451292    colorMedian = (NcBlue > 0) ? C_blue[(int)(0.5*NcBlue)] : NAN;
    452293    average[0].refColorBlue = colorMedian;
    453     dsort (C_red, NcRed);
     294    fsort (C_red, NcRed);
    454295    colorMedian = (NcRed > 0) ? C_red[(int)(0.5*NcRed)] : NAN;
    455296    average[0].refColorRed = colorMedian;
     297
     298    free (C_blue);
     299    free (C_red);
    456300  }
    457301
    … …  
    459303  // XXXX for now, just use the mode as the result:
    460304  int result = mode;
     305  FitAstromResult fit;
     306  FitAstromResultInit (&fit);
    461307
    462308  switch (result) {
    463309    case FIT_AVERAGE:
    464310      average[0].flags |= ID_STAR_USE_AVE;
    465       fit = fitAve;
     311      fit = fitPos;
    466312      break;
    467313    case FIT_PM_ONLY:
    … …  
    471317    case FIT_PM_AND_PAR:
    472318      average[0].flags |= ID_STAR_USE_PAR;
    473       fit = fitPAR;
     319      fit = fitPar;
    474320      break;
    475321  }
    … …  
    503349
    504350  // what is the offset relative to the mean fit position?
    505   coords.crval1 = average[0].R;
    506   coords.crval2 = average[0].D;
    507   if (isnan(coords.crval1)) {
     351  fitStats->coords.crval1 = average[0].R;
     352  fitStats->coords.crval2 = average[0].D;
     353  if (isnan(fitStats->coords.crval1)) {
    508354    return (FALSE);
    509355  }
    510   if (isnan(coords.crval2)) {
     356  if (isnan(fitStats->coords.crval2)) {
    511357    return (FALSE);
    512358  }
    513359
    514360  double dXoff, dYoff;
    515   RD_to_XY (&dXoff, &dYoff, fit.Ro, fit.Do, &coords);
     361  RD_to_XY (&dXoff, &dYoff, fit.Ro, fit.Do, &fitStats->coords);
    516362  float dPos = hypot (dXoff, dYoff);
    517363  if (dPos > MaxMeanOffset) {
    518364    if (fitStats->Noffset < 100) {
    519       fprintf (stderr, "(%f,%f) -> (%f,%f) (%f,%f)\n", coords.crval1, coords.crval2, fit.Ro, fit.Do, dXoff, dYoff);
     365      fprintf (stderr, "(%f,%f) -> (%f,%f) (%f,%f)\n", fitStats->coords.crval1, fitStats->coords.crval2, fit.Ro, fit.Do, dXoff, dYoff);
    520366    }
    521367    fitStats->Noffset ++;
    … …  
    531377                      average[0].uR,
    532378                      average[0].uD,
    533                       fitAve.chisq, fitPM.chisq, fitPAR.chisq);
     379                      fitPos.chisq, fitPM.chisq, fitPar.chisq);
    534380
    535381  average[0].R          = fit.Ro; // RA in degrees
    … …  
    546392  average[0].dP         = fit.dp; // parallax error in arcsec
    547393
    548   average[0].ChiSqAve   = fitAve.chisq;
     394  average[0].ChiSqAve   = fitPos.chisq;
    549395  average[0].ChiSqPM    = fitPM.chisq;
    550   average[0].ChiSqPar   = fitPAR.chisq;
    551 
    552   average[0].Tmean      = (Tmean * 86400 * 365.25) + T2000;
     396  average[0].ChiSqPar   = fitPar.chisq;
     397
     398  average[0].Tmean      = (Tmean * 86400 * 365.25) + fitStats->T2000;
    553399  average[0].Trange     = (Trange * 86400 * 365.25);
    554400  average[0].Npos       = fit.Nfit;
    … …  
    563409// be called with just MeasureTiny set and Measure == NULL
    564410int UpdateObjects_Stack (Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int Nsecfilt, FitStats *fitStats) {
    565 
    566   off_t k;
    567411
    568412  // set the default values
    … …  
    573417
    574418  /* calculate the average value of R,D for a single star */
    575   PMFit fitAve;
    576   memset (&fitAve, 0, sizeof(fitAve));
    577   fitAve.chisq = NAN;
     419  FitAstromResult fitPos;
     420  FitAstromResultInit (&fitPos);
    578421
    579422  if (average[0].Nmeasure == 0) return TRUE;
    580 
    581   int N = 0;
    582423
    583424  int XVERB = FALSE;
    … …  
    585426  XVERB |= (average[0].objID == OBJ_ID_DST) && (average[0].catID == CAT_ID_DST);
    586427
     428  // select the measurements to be used in this analysis
     429  UpdateObjects_SelectMeasures (fitStats, average, secfilt, measure, measureBig, TRUE);
     430
     431  // too few measurements for average position (require 2 values)
     432  if (fitStats->Npoints < 1) return FALSE; // XXX ??
     433 
     434  double Tmean, Trange, parRange;
     435  FitAstromPoints_Project (fitStats, &Tmean, &Trange, &parRange);
     436
     437  FitPosPMfixed (&fitPos, fitStats->fitdataPos, fitStats->points, fitStats->Npoints);
     438  FitAstromSetChisq (&fitPos, fitStats->points, fitStats->Npoints, FIT_AVERAGE);
     439
     440  // project Ro, Do back to RA,DEC
     441  XY_to_RD (&fitPos.Ro, &fitPos.Do, fitPos.Ro, fitPos.Do, &fitStats->coords);
     442
     443  // XXX choose stack flag? average[0].flags |= ID_STAR_FIT_AVE;
     444  fitStats->Nave ++;
     445
     446  if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f)\n",
     447                      average[0].R,
     448                      average[0].D,
     449                      fitPos.Ro, fitPos.Do,
     450                      3600*(average[0].R - fitPos.Ro),
     451                      3600*(average[0].D - fitPos.Do));
     452
     453  // make sure that the fit succeeded
     454  int status = TRUE;
     455  status &= finite(fitPos.Ro);
     456  status &= finite(fitPos.Do);
     457  status &= finite(fitPos.dRo);
     458  status &= finite(fitPos.dDo);
     459  if (!status) {
     460    fitStats->Nskip ++;
     461    return FALSE;
     462  }
     463
     464  // what is the offset relative to the mean fit position?
     465  fitStats->coords.crval1 = average[0].R;
     466  fitStats->coords.crval2 = average[0].D;
     467
     468  double dXoff, dYoff;
     469  RD_to_XY (&dXoff, &dYoff, fitPos.Ro, fitPos.Do, &fitStats->coords);
     470  float dPos = hypot (dXoff, dYoff);
     471  if (dPos > MaxMeanOffset) {
     472    if (fitStats->Noffset < 100) {
     473      fprintf (stderr, "(%f,%f) -> (%f,%f) (%f,%f)\n", fitStats->coords.crval1, fitStats->coords.crval2, fitPos.Ro, fitPos.Do, dXoff, dYoff);
     474    }
     475    fitStats->Noffset ++;
     476    return FALSE;
     477  }
     478
     479  // set the stack position values
     480  average[0].Rstk  = fitPos.Ro; // RA in degrees
     481  average[0].Dstk  = fitPos.Do; // DEC in degrees
     482  average[0].dRstk = fitPos.dRo; // RA scatter in arcsec
     483  average[0].dDstk = fitPos.dDo; // DEC scatter in arcsec
     484
     485  return (TRUE);
     486}
     487
     488int UpdateObjects_SelectMeasures (FitStats *fit, Average *average, SecFilt *secfilt, MeasureTiny *measure, Measure *measureBig, int isStack) {
     489
     490  // I've already allocated fit->points (and fit->sample) with space for fit->NpointsAlloc entries
     491
     492  int has2MASS = FALSE;
     493
     494  int Npoints = fit->Npoints = 0;
     495  FitAstromPoint *points = fit->points;
     496
     497  int TESTPT2 = FALSE;
     498  TESTPT2 |= CAT_ID_SRC && OBJ_ID_SRC && (average[0].catID == CAT_ID_SRC) && (average[0].objID == OBJ_ID_SRC);
     499  TESTPT2 |= CAT_ID_DST && OBJ_ID_DST && (average[0].catID == CAT_ID_DST) && (average[0].objID == OBJ_ID_DST);
     500  if (TESTPT2) {
     501    fprintf (stderr, "got test det\n");
     502  }
     503
    587504  // find the basic properties of the detections for this object (Tmin, Tmax, Tmean)
     505  off_t k;
    588506  for (k = 0; k < average[0].Nmeasure; k++) {
    589507
    590     if (XVERB) {
     508    if (0) {
    591509      char *date = ohana_sec_to_date (measure[k].t);
    592510      int dbFlagsBig = measureBig ? measureBig[k].dbFlags : 0;
    593       fprintf (stderr, "stack: "OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n",  k, measure[k].R, measure[k].D, date, measure[k].dbFlags, dbFlagsBig);
     511      fprintf (stderr, OFF_T_FMT" %f %f %s : 0x%08x : 0x%08x\n",  k, measure[k].R, measure[k].D, date, measure[k].dbFlags, dbFlagsBig);
    594512      free (date);
    595513    }
    596514
    597     // SKIP everything except gpc1 stack data
    598     if (!isGPC1stack(measure[k].photcode)) continue;
    599 
     515    // SKIP gpc1 forced-warp data
     516    if (isGPC1warp(measure[k].photcode)) continue;
     517
     518    // SKIP gpc1 stack data
     519    if (isStack) {
     520      if (!isGPC1stack(measure[k].photcode)) continue;
     521    } else {
     522      if ( isGPC1stack(measure[k].photcode)) continue;
     523    }
     524
     525    // reset the bit to note that a detection was used (or not)
     526    measure[k].dbFlags &= ~ID_MEAS_USED_OBJ;
     527    if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_USED_OBJ; }
     528
     529    // does the measurement pass the supplied filtering constraints?
     530    // MeasFilterTestTiny does not test psfQF
    600531    // exclude bad detections based on: photcodes, psfQF, time range, photflags & astromBadMask, mag_inst
    601532    int keepMeasure = measureBig ? MeasFilterTest(&measureBig[k], FALSE) : MeasFilterTestTiny(&measure[k], FALSE);
    … …  
    604535    }
    605536
    606     R[N] = getMeanR (&measure[k], average, secfilt);
    607     D[N] = getMeanD (&measure[k], average, secfilt);
    608 
    609     // dX, dY : error in arcsec --
    610     dX[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_RA);
    611     dY[N] = GetAstromErrorTiny (&measure[k], ERROR_MODE_DEC);
     537    double Ri = measure[k].R;
     538    double Di = measure[k].D;
     539
     540    // mark (as POOR) any measurements which are deviant from the mean by > ExcludeBogusRadius
     541    if (ExcludeBogus) {
     542      fit->coords.crval1 = average[0].R;
     543      fit->coords.crval2 = average[0].D;
     544      double Xi, Yi;
     545      RD_to_XY (&Xi, &Yi, Ri, Di, &fit->coords);
     546      double radius = hypot(Xi, Yi);
     547      if (radius > ExcludeBogusRadius) {
     548        measure[k].dbFlags |= ID_MEAS_POOR_ASTROM;
     549        if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_POOR_ASTROM; }
     550        continue;
     551      }
     552      measure[k].dbFlags &= ~ID_MEAS_POOR_ASTROM;
     553      if (measureBig) { measureBig[k].dbFlags &= ~ID_MEAS_POOR_ASTROM; }
     554    }
     555
     556    // outlier rejection
     557    if (FALSE && FlagOutlier && (measure[k].dbFlags & ID_MEAS_POOR_ASTROM)) {
     558      continue;
     559    }
     560
     561    FitAstromPointInit (&points[Npoints]);
     562
     563    points[Npoints].R = Ri;
     564    points[Npoints].D = Di;
     565
     566    // measure[k].t is UNIX seconds, T2000 is UNIX seconds for J2000.
     567    // T[] is time in years since J2000 (jd = 2451545)
     568    points[Npoints].T = (measure[k].t - fit->T2000) / (86400*365.25) ; // time relative to J2000 in years
     569
     570    // add measured systematic error in quadrature?  only do this after the fit has
     571    // converged (or you will never improve the poor images)
     572
     573    // dX,dY are the X and Y direction errors in arcseconds.  dR, dD are the errors in
     574    // those directions in degrees.  IF we have non-circular errors (different values for
     575    // X and Y), then dR and dD will be incorrect: they would need to be rotated to take
     576    // out the position angle
     577
     578    // dX, dY : error in arcsec:
     579    points[Npoints].dX = GetAstromErrorTiny (&measure[k], ERROR_MODE_RA);
     580    points[Npoints].dY = GetAstromErrorTiny (&measure[k], ERROR_MODE_DEC);
    612581
    613582    // allow a given photcode or measurement to be
    614583    // ignored if the error is NAN (for photcode, set astromErrSys to NaN)
    615     if (isnan(dX[N])) continue;
    616     if (isnan(dY[N])) continue;
    617 
    618     // XXX this is (slightly) inconsistent: dX,dY are the X and Y direction errors in
    619     // arcseconds.  dR, dD are the errors in those directions in degrees.  IF we have
    620     // non-circular errors (different values for X and Y), then dR and dD will be
    621     // incorrect: they would need to be rotated to take out the position angle
    622     dR[N] = dX[N] / 3600.0;
    623     dD[N] = dY[N] / 3600.0;
    624 
    625     // XXX use a different flag for stack measurements?
    626     // measure[k].dbFlags |= ID_MEAS_USED_OBJ;
    627     // if (measureBig) { measureBig[k].dbFlags |= ID_MEAS_USED_OBJ; }
    628 
    629     N++;
     584    if (isnan(points[Npoints].dX)) continue;
     585    if (isnan(points[Npoints].dY)) continue;
     586
     587    points[Npoints].dT = measure[k].dt;
     588
     589    points[Npoints].measure = k;
     590    Npoints++;
     591
     592    if ((measure[k].photcode >= 2011) && (measure[k].photcode <= 2013)) {
     593      has2MASS = TRUE;
     594    }
     595
     596    myAssert (Npoints <= fit->NpointsAlloc, "oops");
    630597  } // loop over measurements : average[0].Nmeasure
    631598
    632   // if we have too few good detections for the desired fit, or too limited a
    633   // baseline, use a fit with fewer parameters.  XXX if we have too few measurements
    634   // for even the average position, consider including the lower-quality detections?
    635 
    636   // too few measurements for average position (require 2 values)
    637   if (N < 1) return FALSE; // XXX ??
    638 
    639   // find the mean position
    640   StatType statsR, statsD;
    641   liststats_pos (R, dR, N, &statsR, XVERB); // WARNING: this function modifies R (do not use after here)
    642   liststats_pos (D, dD, N, &statsD, XVERB); // WARNING: this function modifies D (do not use after here)
    643 
    644   fitAve.Ro = statsR.mean;
    645   fitAve.dRo = 3600.0*statsR.sigma;
    646 
    647   fitAve.Do = statsD.mean;
    648   fitAve.dDo = 3600.0*statsD.sigma;
    649 
    650   fitAve.chisq = 0.5 * (statsR.chisq + statsD.chisq);
    651   fitAve.Nfit = N;
    652 
    653   // XXX choose stack flag? average[0].flags |= ID_STAR_FIT_AVE;
    654   fitStats->Nave ++;
    655 
    656   if (XVERB) fprintf (stderr, "%f %f -> %f %f (%f,%f)\n",
    657                       average[0].R,
    658                       average[0].D,
    659                       fitAve.Ro, fitAve.Do,
    660                       3600*(average[0].R - fitAve.Ro),
    661                       3600*(average[0].D - fitAve.Do));
    662 
    663   // make sure that the fit succeeded
    664   int status = TRUE;
    665   status &= finite(fitAve.Ro);
    666   status &= finite(fitAve.Do);
    667   status &= finite(fitAve.dRo);
    668   status &= finite(fitAve.dDo);
    669   if (!status) {
    670     fitStats->Nskip ++;
    671     return FALSE;
    672   }
    673 
    674   // what is the offset relative to the mean fit position?
    675   coords.crval1 = average[0].R;
    676   coords.crval2 = average[0].D;
    677 
    678   double dXoff, dYoff;
    679   RD_to_XY (&dXoff, &dYoff, fitAve.Ro, fitAve.Do, &coords);
    680   float dPos = hypot (dXoff, dYoff);
    681   if (dPos > MaxMeanOffset) {
    682     if (fitStats->Noffset < 100) {
    683       fprintf (stderr, "(%f,%f) -> (%f,%f) (%f,%f)\n", coords.crval1, coords.crval2, fitAve.Ro, fitAve.Do, dXoff, dYoff);
    684     }
    685     fitStats->Noffset ++;
    686     return FALSE;
    687   }
    688 
    689   // set the stack position values
    690   average[0].Rstk  = fitAve.Ro; // RA in degrees
    691   average[0].Dstk  = fitAve.Do; // DEC in degrees
    692   average[0].dRstk = fitAve.dRo; // RA scatter in arcsec
    693   average[0].dDstk = fitAve.dDo; // DEC scatter in arcsec
    694 
     599  int TESTPT = FALSE;
     600  TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (average[0].catID == CAT_ID_SRC) && (average[0].objID == OBJ_ID_SRC);
     601  TESTPT |= CAT_ID_DST && OBJ_ID_DST && (average[0].catID == CAT_ID_DST) && (average[0].objID == OBJ_ID_DST);
     602  if (TESTPT) {
     603    fprintf (stderr, "got test det\n");
     604  }
     605 
     606  // XXX flag measurements from stars with 2MASS
     607  for (k = 0; k < average[0].Nmeasure; k++) {
     608    // reset the bit to note that a detection was used (or not)
     609    if (has2MASS) {
     610      measure[k].dbFlags |=  ID_MEAS_OBJECT_HAS_2MASS;
     611    } else {
     612      measure[k].dbFlags &= ~ID_MEAS_OBJECT_HAS_2MASS;
     613    }
     614  }
     615
     616  fit->Npoints = Npoints;
     617  return TRUE;
     618}
     619
     620int FitAstromPoints_Project (FitStats *fitStats, double *Tmean, double *Trange, double *parRange) {
     621
     622  int k;
     623
     624  int Npoints = fitStats->Npoints;
     625  FitAstromPoint *points = fitStats->points;
     626
     627  // find Tmin & Tmax from the list of accepted measurements
     628  double Tmin  = points[0].T;
     629  double Tmax  = points[0].T;
     630  double pRmin = +2.0;
     631  double pRmax = -2.0;
     632  double pDmin = +2.0;
     633  double pDmax = -2.0;
     634
     635  *Tmean = 0.0;
     636
     637  double Tsum = 0.0;
     638  double Wsum = 0.0;
     639  for (k = 0; k < Npoints; k++) {
     640    Tmin = MIN(Tmin, points[k].T);
     641    Tmax = MAX(Tmax, points[k].T);
     642
     643    float wx = 1.0 / SQ(points[k].dX);
     644
     645    Tsum += points[k].T * wx;
     646    Wsum += wx;
     647
     648    // at this point, T is in years since J2000
     649    ParFactor (&points[k].pR, &points[k].pD, points[k].R, points[k].D, points[k].T);
     650    pRmin = MIN (pRmin, points[k].pR);
     651    pRmax = MAX (pRmax, points[k].pR);
     652    pDmin = MIN (pDmin, points[k].pD);
     653    pDmax = MAX (pDmax, points[k].pD);
     654  }
     655  *Trange = Tmax - Tmin;
     656
     657  // mean epoch
     658  *Tmean = Tsum / Wsum;
     659
     660  // for HIGH_SPEED, just use the center of the range
     661  if (RELASTRO_OP == OP_HIGH_SPEED) {
     662    *Tmean = 0.5*(Tmax - Tmin);
     663  }
     664
     665  *parRange = hypot (pRmax - pRmin, pDmax - pDmin);
     666
     667  /* we need to do the fit in a locally linear space; choose a ref coordinate */
     668  fitStats->coords.crval1 = points[0].R;
     669  fitStats->coords.crval2 = points[0].D;
     670
     671  // project all of the R,D coordinates to a plane centered on this coordinate. set
     672  // the times to be relative to Tmean
     673  for (k = 0; k < Npoints; k++) {
     674    RD_to_XY (&points[k].X, &points[k].Y, points[k].R, points[k].D, &fitStats->coords);
     675    points[k].T -= *Tmean;
     676  }       
     677  return TRUE;
     678}
     679
     680int CatalogMaxNmeasure (Catalog *catalog, int Ncatalog) {
     681
     682  int i, j;
     683
     684  int Nmax = 0;
     685  for (i = 0; i < Ncatalog; i++) {
     686    for (j = 0; j < catalog[i].Naverage; j++) {
     687      Nmax = MAX (Nmax, catalog[i].average[j].Nmeasure);
     688    }
     689  }
     690  return Nmax;
     691}
     692
     693int BootstrapResample (FitAstromPoint *sample, FitAstromPoint *points, int Npoints) {
     694  int i;
     695
     696  // I need to draw Npoints random entries from 'points' with replacement:
     697  for (i = 0; i < Npoints; i++) {
     698    int N = Npoints * drand48();
     699    sample[i] = points[N];
     700  }
     701  return TRUE;
     702}
     703
     704// calculate mean and sigma points for the 5 fit parameter
     705int BootstrapRobustStats (FitAstromResult *result, FitAstromResult *fit, int Nfit, int mode) {
     706
     707  // generate a histogram for the selected element
     708  double *values = NULL;
     709  ALLOCATE (values, double, Nfit);
     710 
     711  int i;
     712
     713  for (i = 0; i < Nfit; i++) {
     714    switch (mode) {
     715      case FIT_RESULT_RA:
     716        values[i] = fit[i].Ro;
     717        break;
     718      case FIT_RESULT_DEC:
     719        values[i] = fit[i].Do;
     720        break;
     721      case FIT_RESULT_uR:
     722        values[i] = fit[i].uR;
     723        break;
     724      case FIT_RESULT_uD:
     725        values[i] = fit[i].uD;
     726        break;
     727      case FIT_RESULT_PLX:
     728        values[i] = fit[i].p;
     729        break;
     730      default:
     731        myAbort ("invalid option");
     732    }
     733  }
     734
     735  dsort (values, Nfit);
     736
     737  double median;
     738  if (Nfit % 2) {
     739    int Ncenter = Nfit / 2;
     740    median = values[Ncenter];
     741  } else {
     742    int Ncenter = Nfit / 2 - 1;
     743    median = 0.5*(values[Ncenter] + values[Ncenter + 1]);
     744  }
     745
     746  double Slo = VectorFractionInterpolate (values, 0.158655, Nfit);
     747  double Shi = VectorFractionInterpolate (values, 0.841345, Nfit);
     748  double sigma = (Shi - Slo) / 2.0;
     749
     750  switch (mode) {
     751    case FIT_RESULT_RA:
     752      result->Ro = median;
     753      result->dRo = sigma;
     754      break;
     755    case FIT_RESULT_DEC:
     756      result->Do = median;
     757      result->dDo = sigma;
     758      break;
     759    case FIT_RESULT_uR:
     760      result->uR = median;
     761      result->duR = sigma;
     762      break;
     763    case FIT_RESULT_uD:
     764      result->uD = median;
     765      result->duD = sigma;
     766      break;
     767    case FIT_RESULT_PLX:
     768      result->p = median;
     769      result->dp = sigma;
     770      break;
     771    default:
     772      myAbort ("invalid option");
     773  }
     774
     775  return TRUE;
     776}
     777
     778double VectorFractionInterpolate (double *values, float fraction, int Npts) {
     779
     780  float F = fraction * Npts;
     781  int   N = fraction * Npts;
     782
     783  if (N < 0        ) return NAN;
     784  if (N >= Npts - 2) return NAN;
     785
     786  // interpolate between N,N+1
     787   
     788  double S = (F - N) * (values[N+1] - values[N]) + values[N];
     789  return S;
     790}
     791
     792int FitAstromSetChisq (FitAstromResult *fit, FitAstromPoint *points, int Npoints, FitMode mode) {
     793
     794  int i;
     795
     796  // add up the chi square for the fit
     797  double chisq = 0.0;
     798  for (i = 0; i < Npoints; i++) {
     799    double Xf = fit->Ro + fit->uR*points[i].T + fit->p*points[i].pR;
     800    double Yf = fit->Do + fit->uD*points[i].T + fit->p*points[i].pD;
     801    chisq += SQ(points[i].X - Xf) / SQ(points[i].dX);
     802    chisq += SQ(points[i].Y - Yf) / SQ(points[i].dY);
     803  }
     804  switch (mode) {
     805    case FIT_AVERAGE:
     806      fit->chisq = chisq / (2.0*Npoints - 2.0);
     807      break;
     808    case FIT_PM_ONLY:
     809      fit->chisq = chisq / (2.0*Npoints - 4.0);
     810      break;
     811    case FIT_PM_AND_PAR:
     812      fit->chisq = chisq / (2.0*Npoints - 5.0);
     813      break;
     814    default:
     815      myAbort ("invalid mode");
     816  }
     817  fit->Nfit = Npoints;
    695818  return (TRUE);
    696819}
    697820
    698 
    699 
    700 /* fitting proper-motion and parallax:
    701 
    702    given a source at position r,d, at a time t, we need to calculate a vector (pr,pd)
    703 
    704    let x,y be the coordinate in the linearized frame with y parallel to DEC lines
    705 
    706    L,B are the ecliptic longitude and latitude of the object,
    707    dL and dB are the offsets in the L and B directions
    708 
    709    dL = sin(t - topp)
    710    dB = cos(t - topp)*sin(B)
    711 
    712    these need to be rotated to the R,D frame to yield pR,pD.  Then, the equation of motion
    713    for the source in the x,y frame is:
    714 
    715    x = Ro + uR * (t - to) + p * pR
    716    y = Do + uD * (t - to) + p * pD
    717 
    718    the unknowns in these equations are Ro, uR, Do, uD, and p
    719 
    720    XXX think through the concepts for the pole a bit better.  all objects near the pole
    721    move the same way with the same phase.  choose a projection center and define dL,dB relative
    722    to that center point coordinate system?
    723 
    724 */
     821int FitAstromResultSetPM (FitAstromResult *fit, int Nfit, Average *average) {
     822
     823  int i;
     824
     825  if (USE_GALAXY_MODEL) {
     826    for (i = 0; i < Nfit; i++) {
     827      fit->uR = average->uRgal;
     828      fit->uD = average->uDgal;
     829    }
     830  } else {
     831    for (i = 0; i < Nfit; i++) {
     832      fit->uR = 0.0;
     833      fit->uD = 0.0;
     834    }
     835  }
     836
     837  return TRUE;
     838}

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

    r38441 r38986  
    253253  }
    254254
     255  // If we are looking at the whole sky (or whole relevant sky), use the full image table
     256  // -- this save substantial memory.  this could be automatic if the skyregion covers
     257  // more than 2pi.
     258  USE_ALL_IMAGES = FALSE;
     259  if ((N = get_argument (argc, argv, "-use-all-images"))) {
     260    remove_argument (N, &argc, argv);
     261    USE_ALL_IMAGES = TRUE;
     262  }
     263
    255264  USE_BASIC_CHECK = FALSE;
    256265  if ((N = get_argument (argc, argv, "-basic-image-search"))) {
    … …  
    271280    remove_argument (N, &argc, argv);
    272281    APPLY_OFFSETS = TRUE;
     282  }
     283
     284  N_BOOTSTRAP_SAMPLES = 1;
     285  if ((N = get_argument (argc, argv, "-bootstrap-samples"))) {
     286    remove_argument (N, &argc, argv);
     287    N_BOOTSTRAP_SAMPLES = atoi (argv[N]);
     288    remove_argument (N, &argc, argv);
     289    if ((N_BOOTSTRAP_SAMPLES < 1) || ((N_BOOTSTRAP_SAMPLES > 1) && (N_BOOTSTRAP_SAMPLES < 20))) {
     290      fprintf (stderr, "-bootstrap-samples must be either 1 (no sampling) or >= 20\n");
     291      exit (2);
     292    }
    273293  }
    274294
    … …  
    685705  }
    686706
     707  // If we are looking at the whole sky (or whole relevant sky), use the full image table
     708  // -- this save substantial memory.  this could be automatic if the skyregion covers
     709  // more than 2pi.
     710  USE_ALL_IMAGES = FALSE;
     711  if ((N = get_argument (argc, argv, "-use-all-images"))) {
     712    remove_argument (N, &argc, argv);
     713    USE_ALL_IMAGES = TRUE;
     714  }
     715
    687716  USE_BASIC_CHECK = FALSE;
    688717  if ((N = get_argument (argc, argv, "-basic-image-search"))) {
    … …  
    697726    remove_argument (N, &argc, argv);
    698727    MaxDensityUse = TRUE;
     728  }
     729
     730  N_BOOTSTRAP_SAMPLES = 1;
     731  if ((N = get_argument (argc, argv, "-bootstrap-samples"))) {
     732    remove_argument (N, &argc, argv);
     733    N_BOOTSTRAP_SAMPLES = atoi (argv[N]);
     734    remove_argument (N, &argc, argv);
     735    if ((N_BOOTSTRAP_SAMPLES < 1) || ((N_BOOTSTRAP_SAMPLES > 1) && (N_BOOTSTRAP_SAMPLES < 20))) {
     736      fprintf (stderr, "-bootstrap-samples must be either 1 (no sampling) or >= 20\n");
     737      exit (2);
     738    }
    699739  }
    700740

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

    r38441 r38986  
    2626  char mapfile[DVO_MAX_PATH];
    2727  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
    28   AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, VERBOSE);
     28  AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, 100000, VERBOSE);
    2929
    3030  // assign images.coords.offsetMap -> table->map[i]

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

    r38441 r38986  
    112112
    113113    // if we want to correct to the galay model, we need to use objects with distances determined by Green & Schlafly
    114     if (USE_GALAXY_MODEL && !catalog[0].average[i].Nstarpar) {
    115       // we may want to add some starpar quality filters...
    116       continue;
     114    if (USE_GALAXY_MODEL) {
     115      // if we use the galaxy model, we need to require the model pm to exist
     116      if (!catalog[0].average[i].Nstarpar) continue;
     117      if (!isfinite(catalog[0].average[i].uRgal)) continue;
     118      if (!isfinite(catalog[0].average[i].uDgal)) continue;
     119    }
     120
     121    int TESTPT = FALSE;
     122    TESTPT |= CAT_ID_SRC && OBJ_ID_SRC && (catalog[0].average[i].catID == CAT_ID_SRC) && (catalog[0].average[i].objID == OBJ_ID_SRC);
     123    TESTPT |= CAT_ID_DST && OBJ_ID_DST && (catalog[0].average[i].catID == CAT_ID_DST) && (catalog[0].average[i].objID == OBJ_ID_DST);
     124    if (TESTPT) {
     125      fprintf (stderr, "got test det\n");
    117126    }
    118127

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

    r38471 r38986  
    153153              PHOTCODE_A_LIST, PHOTCODE_B_LIST, RADIUS, outputDir, table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
    154154
     155    strextend (&command, "relastro_client -high-speed %s %s %f %s", PHOTCODE_A_LIST, PHOTCODE_B_LIST, RADIUS, outputDir);
     156    strextend (&command, "-hostID %d", table->hosts[i].hostID);
     157    strextend (&command, "-D CATDIR %s", CATDIR);
     158    strextend (&command, "-hostdir %s", table->hosts[i].pathname);
     159    strextend (&command, "-region %f %f %f %f", UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
     160
    155161    free (outputDir);
    156162
    … …  
    166172    if (MaxDensityUse) { strextend (&command, "-max-density %f", MaxDensityValue); }
    167173   
     174    if (USE_ALL_IMAGES)      { strextend (&command, "-use-all-images"); }
    168175    if (USE_BASIC_CHECK)     { strextend (&command, "-basic-image-search"); }
    169176    if (FlagOutlier)         { strextend (&command, "-clip %d", CLIP_THRESH); }
    … …  
    176183    // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values
    177184
    178     if (MinBadQF > 0.0)        { strextend (&command, "-min-bad-psfqf %f", MinBadQF); }
    179     if (MaxMeanOffset != 10.0) { strextend (&command, "-max-mean-offset  %f", MaxMeanOffset); }
     185    if (MinBadQF > 0.0)          strextend (&command, "-min-bad-psfqf %f", MinBadQF);
     186    if (MaxMeanOffset != 10.0)   strextend (&command, "-max-mean-offset  %f", MaxMeanOffset);
     187    if (N_BOOTSTRAP_SAMPLES > 1) strextend (&command, "-bootstrap-samples %d", N_BOOTSTRAP_SAMPLES);
    180188
    181189    if (WHERE_A[0]) { strextend (&command, "-D WHERE_A \"%s\"", WHERE_A); }

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

    r38441 r38986  
    270270
    271271  fprintf (stderr, "found %d matches\n", Nmatch);
    272   dvo_catalog_save (&catalogOut, VERBOSE2);
    273   dvo_catalog_unlock (&catalogOut);
     272
     273  SetProtect (TRUE);
     274  if (!dvo_catalog_save (&catalogOut, VERBOSE2)) { fprintf (stderr, "ERROR: failed to save %s\n", catalogOut.filename); exit (1); }
     275  if (!dvo_catalog_unlock (&catalogOut)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalogOut.filename); exit (1); }
     276  SetProtect (FALSE);
     277
    274278  dvo_catalog_free (&catalogOut);
    275279  free (slowMoving);

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

    r38471 r38986  
    148148
    149149    char *command = NULL;
    150     strextend (&command, "relastro_client -hpm %f %s -hostID %d -D CATDIR %s -hostdir %s -region %f %f %f %f",
    151               RADIUS, outputDir, table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
     150    strextend (&command, "relastro_client -hpm %f %s", RADIUS, outputDir);
     151    strextend (&command, " -hostID %d", table->hosts[i].hostID);
     152    strextend (&command, " -D CATDIR %s", CATDIR);
     153    strextend (&command, " -hostdir %s", table->hosts[i].pathname);
     154    strextend (&command, " -region %f %f %f %f", UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
    152155
    153156    free (outputDir);
    … …  
    164167    if (MaxDensityUse) { strextend (&command, "-max-density %f", MaxDensityValue); }
    165168   
     169    if (USE_ALL_IMAGES)      { strextend (&command, "-use-all-images"); }
    166170    if (USE_BASIC_CHECK)     { strextend (&command, "-basic-image-search"); }
    167171    if (FlagOutlier)         { strextend (&command, "-clip %d", CLIP_THRESH); }
    … …  
    174178    // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values
    175179
    176     if (MinBadQF > 0.0)        { strextend (&command, "-min-bad-psfqf %f", MinBadQF); }
    177     if (MaxMeanOffset != 10.0) { strextend (&command, "-max-mean-offset  %f", MaxMeanOffset); }
     180    if (MinBadQF > 0.0)          strextend (&command, "-min-bad-psfqf %f", MinBadQF);
     181    if (MaxMeanOffset != 10.0)   strextend (&command, "-max-mean-offset  %f", MaxMeanOffset);
     182    if (N_BOOTSTRAP_SAMPLES > 1) strextend (&command, "-bootstrap-samples %d", N_BOOTSTRAP_SAMPLES);
    178183
    179184    if (TimeSelect) {

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

    r38441 r38986  
    110110  if (catalog[0].Naverage == Nslow) {
    111111    fprintf (stderr, "no possible fast objects, skipping this catalog\n");
    112     dvo_catalog_save (&catalogOut, VERBOSE2);
    113     dvo_catalog_unlock (&catalogOut);
     112
     113    SetProtect (TRUE);
     114    if (!dvo_catalog_save (&catalogOut, VERBOSE2)) { fprintf (stderr, "ERROR: failed to save %s\n", catalogOut.filename); exit (1); }
     115    if (!dvo_catalog_unlock (&catalogOut)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalogOut.filename); exit (1); }
     116    SetProtect (FALSE);
     117
    114118    dvo_catalog_free (&catalogOut);
    115119    free (slowMoving);

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

    r38441 r38986  
    66  int i;
    77
    8   // do not remote the sync and fits files if we do a manual run -- user must clear if needed
     8  // do not remove the sync and fits files if we do a manual run -- user must clear if needed
    99  if (!PARALLEL_REGIONS_MANUAL) {
    1010    // clear the I/O files

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

    r38471 r38986  
    163163
    164164    char *command = NULL;
    165     strextend (&command, "relastro_client -load-objects %s -hostID %d -D CATDIR %s -hostdir %s -region %f %f %f %f -statmode %s -minerror %f -D RELASTRO_SIGMA_LIM %f",
    166               table->hosts[i].results, table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE, MIN_ERROR, SIGMA_LIM);
     165    strextend (&command, "relastro_client -load-objects %s", table->hosts[i].results);
     166    strextend (&command, " -hostID %d", table->hosts[i].hostID);
     167    strextend (&command, " -D CATDIR %s", CATDIR);
     168    strextend (&command, " -hostdir %s", table->hosts[i].pathname);
     169    strextend (&command, " -region %f %f %f %f", UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
     170    strextend (&command, " -statmode %s", STATMODE);
     171    strextend (&command, " -minerror %f", MIN_ERROR);
     172    strextend (&command, " -D RELASTRO_SIGMA_LIM %f", SIGMA_LIM);
    167173
    168174    if (FIT_MODE == FIT_PM_ONLY)         strextend (&command, "-pm");
    … …  
    188194    }
    189195
     196    if (USE_ALL_IMAGES)      strextend (&command, "-use-all-images");
    190197    if (USE_FIXED_PIXCOORDS) strextend (&command, "-D USE_FIXED_PIXCOORDS 1");
    191198    if (PHOTCODE_KEEP_LIST)  strextend (&command, "+photcode %s", PHOTCODE_KEEP_LIST);

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

    r38441 r38986  
    77 */
    88
    9 int load_images (FITS_DB *db, SkyList *skylist, int UseFullOverlap) {
     9int load_images (FITS_DB *db, SkyList *skylist, int UseFullOverlap, int UseAllImages) {
    1010
    1111  Image     *image, *subset;
    1212  off_t      Nimage, Nsubset;
    13   off_t     *LineNumber;
     13  off_t     *LineNumber, i;
    1414
    1515  INITTIME;
    … …  
    2929  char mapfile[DVO_MAX_PATH];
    3030  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
    31   table = AstromOffsetMapLoad (mapfile, VERBOSE);
     31  table = AstromOffsetMapLoad (mapfile, 100000, VERBOSE);
    3232
    3333  // assign images.coords.offsetMap -> table->map[i]
    … …  
    3939
    4040  // select the images which overlap the selected sky regions
    41   subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset, UseFullOverlap);
    42   MARKTIME("  select images: %f sec\n", dtime);
     41  if (UseAllImages) {
     42    ALLOCATE (LineNumber, off_t, Nimage);
     43    for (i = 0; i < Nimage; i++) LineNumber[i] = i;
     44    subset  = image;
     45    Nsubset = Nimage;
     46  } else {
     47    subset = select_images (skylist, image, Nimage, &LineNumber, &Nsubset, UseFullOverlap);
     48    MARKTIME("  select images: %f sec\n", dtime);
    4349
    44   if (Nsubset == Nimage) {
    45     free (subset);
    46     subset = image;
     50    if (Nsubset == Nimage) {
     51      free (subset);
     52      subset = image;
     53    }
    4754  }
    48 
     55   
    4956  initImages (subset, LineNumber, Nsubset);
    5057  MARKTIME("  init images: %f sec\n", dtime);
    51 
     58 
    5259  initMosaics (subset, Nsubset);
    5360  MARKTIME("  init mosaics: %f sec\n", dtime);

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

    r36630 r38986  
    44
    55  /* get configuration info, args */
     6  SetSignals ();
    67  initialize (argc, argv);
    78

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

    r38441 r38986  
    2222
    2323  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, etc)
     24  SetSignals ();
    2425  initialize_client (argc, argv);
    2526
    … …  
    7879
    7980      /* load regions and images based on specified sky patch (default depth) */
    80       load_images (&db, skylist, FALSE);
     81      load_images (&db, skylist, FALSE, USE_ALL_IMAGES);
    8182     
    8283      // I can free the database after I have loaded the images...

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

    r38441 r38986  
    2121
    2222  /* load regions and images based on specified sky patch (default depth) (require full overlap) */
    23   load_images (&db, skylist, TRUE);
     23  load_images (&db, skylist, TRUE, USE_ALL_IMAGES);
    2424  MARKTIME("load images: %f sec\n", dtime);
    2525
    … …  
    7373      if (RESET_IMAGES) UpdateMeasures (catalog, Ncatalog);
    7474      for (i = 0; i < NLOOP; i++) {
    75         UpdateObjects (catalog, Ncatalog, (i > 0)); // calculate <R>,<D>; if (i > 0), apply Galaxy Motion Model (if desired)
    76         if ((i > 1) || !USE_GALAXY_MODEL) {
    77           // if GALAXY_MODEL is selected, we want to delay the frame correction until we have
    78           // applied the galaxy model a couple of times.
    79           FrameCorrectionSerial (catalog, Ncatalog);
    80         }
    81         UpdateChips (catalog, Ncatalog);   // measure.X,Y -> R,D, fit image.coords
     75        UpdateObjects (catalog, Ncatalog, i); // calculate <R>,<D>; if (i > 0), apply Galaxy Motion Model (if desired)
     76        UpdateChips (catalog, Ncatalog, i);   // measure.X,Y -> R,D, fit image.coords
    8277        MARKTIME("update chips: %f sec\n", dtime);
    8378      }
    … …  
    10398  freeImageBins (1);
    10499
    105   // XXX why do I do this exactly?
    106   reload_images (&db);
     100  // If we did NOT use all images, then we applied the measured corrections to a subset of
     101  // images.  we now need to set the images associated with db to have those values so
     102  // they will be written out by the dvo_image_update() operations.  If we USE_ALL_IMAGES,
     103  // then we do not need to do this, and we should call dvo_image_save (not dvo_image_update)
     104  if (!USE_ALL_IMAGES) {
     105    reload_images (&db);
     106  }
    107107   
    108108  if (PARALLEL) {
    … …  
    110110    // need to also save the image map table...
    111111    save_astrom_table ();
    112     dvo_image_update (&db, VERBOSE);
     112    if (USE_ALL_IMAGES) {
     113      dvo_image_save (&db, VERBOSE);
     114    } else {
     115      dvo_image_update (&db, VERBOSE);
     116    }
    113117    dvo_image_unlock (&db);
    114118  }
    115119
     120  // NOTE: if we have parallel partitions, then we need to save the Images.dat and
     121  // AstroMap.fits tables BEFORE the remote relastro_clients are launched (they load
     122  // Images.dat and AstroMap.fits)
     123
     124  // if we do NOT have parallel partitions, we must NOT write them out yet: the act of
     125  // writing out the files byte-swaps the data and makes the values invalide for the
     126  // following calls to UpdateObjectOffsets (which attempt to apply the image values from
     127  // the structure in memory)
     128
    116129  // iterate over catalogs to make detection coordinates consistant
    117   UpdateObjectOffsets (skylist, 0, NULL);
     130  if (APPLY_OFFSETS) {
     131    UpdateObjectOffsets (skylist, 0, NULL);
     132  }
    118133
    119134  if (!PARALLEL) {
    120135    // save the updated image parameters
    121136    save_astrom_table ();
    122     dvo_image_update (&db, VERBOSE);
     137    if (USE_ALL_IMAGES) {
     138      dvo_image_save (&db, VERBOSE);
     139    } else {
     140      dvo_image_update (&db, VERBOSE);
     141    }
    123142    dvo_image_unlock (&db);
    124143  }

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

    r38441 r38986  
    122122    resort_catalog (&catalog_src);
    123123
    124     dvo_catalog_save (&catalog_src, VERBOSE2);
    125     dvo_catalog_unlock (&catalog_src);
     124    SetProtect (TRUE);
     125    if (!dvo_catalog_save (&catalog_src, VERBOSE2)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog_src.filename); exit (1); }
     126    if (!dvo_catalog_unlock (&catalog_src)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog_src.filename); exit (1); }
     127    SetProtect (FALSE);
    126128    dvo_catalog_free (&catalog_src);
    127129

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

    r38471 r38986  
    150150
    151151    char *command = NULL;
    152     strextend (&command, "relastro_client -update-objects -hostID %d -D CATDIR %s -hostdir %s -region %f %f %f %f -statmode %s",
    153               table->hosts[i].hostID, CATDIR, table->hosts[i].pathname, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax, STATMODE);
     152    strextend (&command, "relastro_client -update-objects");
     153    strextend (&command, "-hostID %d", table->hosts[i].hostID);
     154    strextend (&command, "-D CATDIR %s", CATDIR);
     155    strextend (&command, "-hostdir %s", table->hosts[i].pathname);
     156    strextend (&command, "-region %f %f %f %f", UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
     157    strextend (&command, "-statmode %s", STATMODE);
    154158
    155159    if (FIT_MODE == FIT_PM_ONLY)         { strextend (&command, "-pm"); }
    … …  
    164168    if (MaxDensityUse) { strextend (&command, "-max-density %f", MaxDensityValue); }
    165169    if (FlagOutlier)   { strextend (&command, "-clip %d", CLIP_THRESH); }
     170
     171    if (USE_ALL_IMAGES)      { strextend (&command, "-use-all-images"); }
    166172    if (USE_FIXED_PIXCOORDS) { strextend (&command, "-D USE_FIXED_PIXCOORDS 1"); }
    167173    if (PHOTCODE_KEEP_LIST)  { strextend (&command, "+photcode %s", PHOTCODE_KEEP_LIST); }
    … …  
    172178    // XXX note that the above pass in the flag as decimal -- also note that args.c cannot handle 0xHEX values
    173179
    174     if (MinBadQF > 0.0)        { strextend (&command, "-min-bad-psfqf %f", MinBadQF); }
    175     if (MaxMeanOffset != 10.0) { strextend (&command, "-max-mean-offset  %f", MaxMeanOffset); }
     180    if (MinBadQF > 0.0)          strextend (&command, "-min-bad-psfqf %f", MinBadQF);
     181    if (MaxMeanOffset != 10.0)   strextend (&command, "-max-mean-offset  %f", MaxMeanOffset);
     182    if (N_BOOTSTRAP_SAMPLES > 1) strextend (&command, "-bootstrap-samples %d", N_BOOTSTRAP_SAMPLES);
    176183
    177184    if (TimeSelect) {

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

    r38062 r38986  
    4040  char mapfile[DVO_MAX_PATH];
    4141  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.%d.fits", CATDIR, REGION_HOST_ID);
    42   AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, VERBOSE);
     42  AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, 100000, VERBOSE);
    4343
    4444  // assign images.coords.offsetMap -> table->map[i]
    … …  
    120120      }
    121121      for (i = 0; i < NLOOP; i++) {
    122         UpdateObjects (catalog, Ncatalog, (i > 0));
     122        UpdateObjects (catalog, Ncatalog, i);
    123123        LOGRTIME("UpdateObjects loop %d on %s, host %d: %f sec\n", i, myHostName, REGION_HOST_ID, dtime);
    124         if ((i > 1) || !USE_GALAXY_MODEL) {
    125           // if GALAXY_MODEL is selected, we want to delay the frame correction until we have
    126           // applied the galaxy model a couple of times.
    127           FrameCorrectionParallelSlave (catalog, Ncatalog, regionHosts, i);
    128           LOGRTIME("FrameCorrection loop %d on %s, host %d: %f sec\n", i, myHostName, REGION_HOST_ID, dtime);
    129         }
     124
    130125        share_mean_pos (catalog, Ncatalog, regionHosts, i);
    131126        LOGRTIME("share_mean_pos loop %d on %s, host %d: %f sec\n", i, myHostName, REGION_HOST_ID, dtime);
    … …  
    133128        LOGRTIME("slurp_mean_pos loop %d on %s, host %d: %f sec\n", i, myHostName, REGION_HOST_ID, dtime);
    134129
    135         UpdateChips (catalog, Ncatalog);
     130        UpdateChips (catalog, Ncatalog, i);
    136131        LOGRTIME("UpdateChips loop %d on %s, host %d: %f sec\n", i, myHostName, REGION_HOST_ID, dtime);
    137132

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

    r33652 r38986  
    99
    1010    if (VERBOSE2) fprintf (stderr, "saving catalog %s\n", catalog[i].filename);
    11     dvo_catalog_save (&catalog[i], VERBOSE2);
    12     dvo_catalog_unlock (&catalog[i]);
     11    SetProtect (TRUE);
     12    if (!dvo_catalog_save (&catalog[i], VERBOSE2)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog[i].filename); exit (1); }
     13    if (!dvo_catalog_unlock (&catalog[i])) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog[i].filename); exit (1); }
     14    SetProtect (FALSE);
    1315    dvo_catalog_free (&catalog[i]);
    1416  }

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

    r38062 r38986  
    115115    snprintf (mapname, 1024, "%s/AstroMapUpdate.%d.fits", CATDIR, regionHosts->hosts[i].hostID);
    116116   
    117     AstromOffsetTable *table = AstromOffsetMapLoad (mapname, VERBOSE);
     117    AstromOffsetTable *table = AstromOffsetMapLoad (mapname, 100000, VERBOSE);
    118118    LOGRTIME("image_maps_load host %d loop %d on %s, host %d: %f sec\n", i, nloop, myHostName, REGION_HOST_ID, dtime);
    119119 

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

    r38466 r38986  
    1414// # define IDX_T off_t
    1515# define IDX_T int
     16
     17typedef enum {
     18  STAGE_CHIP  = 0x01,
     19  STAGE_WARP  = 0x02,
     20  STAGE_STACK = 0x04,
     21} RelphotStages;
    1622
    1723typedef enum {
    … …  
    327333int USE_BASIC_CHECK;
    328334int USE_FULL_OVERLAP;
     335
     336RelphotStages STAGES;
    329337
    330338# ifdef GRID_V1

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

    r37037 r38986  
    2121  va_end (argp);
    2222
    23   SetProtect (TRUE);
    24   if (db) gfits_db_close (db);
    2523  fprintf (stderr, "ERROR: relphot halted\n");
    2624  exit (1);

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

    r38466 r38986  
    344344  }
    345345
     346  STAGES = STAGE_CHIP | STAGE_WARP | STAGE_STACK;
     347  if ((N = get_argument (argc, argv, "-skip-chip"))) {
     348    remove_argument (N, &argc, argv);
     349    STAGES &= ~STAGE_CHIP;
     350  }
     351  if ((N = get_argument (argc, argv, "-skip-warp"))) {
     352    remove_argument (N, &argc, argv);
     353    STAGES &= ~STAGE_WARP;
     354  }
     355  if ((N = get_argument (argc, argv, "-skip-stack"))) {
     356    remove_argument (N, &argc, argv);
     357    STAGES &= ~STAGE_STACK;
     358  }
     359  if (!STAGES) {
     360    fprintf (stderr, "ERROR: no valid stages selected\n");
     361    exit (3);
     362  }
     363
    346364  REGION_FILE = NULL;
    347365  if ((N = get_argument (argc, argv, "-region-hosts"))) {
    … …  
    664682  }
    665683
     684  STAGES = STAGE_CHIP | STAGE_WARP | STAGE_STACK;
     685  if ((N = get_argument (argc, argv, "-skip-chip"))) {
     686    remove_argument (N, &argc, argv);
     687    STAGES &= ~STAGE_CHIP;
     688  }
     689  if ((N = get_argument (argc, argv, "-skip-warp"))) {
     690    remove_argument (N, &argc, argv);
     691    STAGES &= ~STAGE_WARP;
     692  }
     693  if ((N = get_argument (argc, argv, "-skip-stack"))) {
     694    remove_argument (N, &argc, argv);
     695    STAGES &= ~STAGE_STACK;
     696  }
     697  if (!STAGES) {
     698    fprintf (stderr, "ERROR: no valid stages selected\n");
     699    exit (3);
     700  }
     701
    666702  if ((MODE == MODE_SYNTH_PHOT)  && (argc == 1)) return TRUE;
    667703  if ((MODE == MODE_UPDATE_OBJECTS)  && (argc == 1)) return TRUE;

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

    r38471 r38986  
    253253  Catalog *catalog = catalogs->catalog;
    254254  *Ncatalog = catalogs->Ncatalog;
    255   BrightCatalogSplitFree (catalogs);
    256255
    257256  int Nmeasure = 0;
    … …  
    263262
    264263  fprintf (stderr, "loaded %d catalogs, using a total of %d stars (%d measures)\n", catalogs->Ncatalog, Naverage, Nmeasure);
     264  client_logger_message ("loaded %d catalogs, using a total of %d stars (%d measures)\n", catalogs->Ncatalog, Naverage, Nmeasure);
     265
     266  BrightCatalogSplitFree (catalogs);
    265267
    266268  return (catalog);

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

    r38441 r38986  
    3131  MARKTIME("build chip match for %d images: %f sec\n", (int) Nimage, dtime);
    3232
     33  // XXX consider allowing relphot to skip the AstroMap load (do we need precise astrometry here?)
     34
    3335  char mapfile[DVO_MAX_PATH];
    3436  snprintf (mapfile, DVO_MAX_PATH, "%s/AstroMap.fits", CATDIR);
    35   AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, VERBOSE);
     37  AstromOffsetTable *table = AstromOffsetMapLoad (mapfile, 100000, VERBOSE);
    3638
    3739  // assign images.coords.offsetMap -> table->map[i]

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

    r38471 r38986  
    105105    free (moddate);
    106106
    107     dvo_catalog_save (&catalog, VERBOSE);
    108     dvo_catalog_unlock (&catalog);
     107    SetProtect (TRUE);
     108    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     109    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     110    SetProtect (FALSE);
    109111
    110112    free_tiny_values(&catalog);
    … …  
    244246    if (SYNTH_ZERO_POINTS) { strextend (&command, "-synthphot-zpts %s", SYNTH_ZERO_POINTS); }
    245247
     248    if (!(STAGES & STAGE_CHIP))  { strextend (&command, "-skip-chip"); }
     249    if (!(STAGES & STAGE_WARP))  { strextend (&command, "-skip-warp"); }
     250    if (!(STAGES & STAGE_STACK)) { strextend (&command, "-skip-stack"); }
     251
    246252    // deprecate
    247253    // if (SET_MREL_VERSION != 1) { snprintf (tmpline, 1024, "%s -set-mrel-version %d", SET_MREL_VERSION); } // XXXX deprecate this...

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

    r38062 r38986  
    44
    55  // get configuration info, args
     6  SetSignals ();
    67  RelphotMode mode = initialize (argc, argv);
    78  if (!mode) exit (2);

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

    r38062 r38986  
    1818
    1919  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, etc)
     20  SetSignals ();
    2021  initialize_client (argc, argv);
    2122  client_logger_init (HOSTDIR);

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

    r38471 r38986  
    101101    // but it would be better to define a dvo crawler program to do this
    102102    // catalog.catformat = DVO_FORMAT_PS1_V1; 
    103     dvo_catalog_save (&catalog, VERBOSE);
    104     dvo_catalog_unlock (&catalog);
     103    SetProtect (TRUE);
     104    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     105    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     106    SetProtect (FALSE);
    105107    free_tiny_values(&catalog);
    106108    dvo_catalog_free (&catalog);
    … …  
    155157    if (SYNTH_ZERO_POINTS) { strextend (&command, "-synthphot-zpts %s", SYNTH_ZERO_POINTS); }
    156158
     159    if (!(STAGES & STAGE_CHIP))  { strextend (&command, "-skip-chip"); }
     160    if (!(STAGES & STAGE_WARP))  { strextend (&command, "-skip-warp"); }
     161    if (!(STAGES & STAGE_STACK)) { strextend (&command, "-skip-stack"); }
     162
    157163    // if (SET_MREL_VERSION != 1) { strextend (&command, "-set-mrel-version %d", SET_MREL_VERSION); }
    158164

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

    r37037 r38986  
    3434    exit (2);
    3535  }
     36  client_logger_message ("loaded images\n");
    3637
    3738  // once we have read this table, we should remove it for repeat runs
    … …  
    5354  // the following function correctly chooses the sky regions on the 0,360 boundary
    5455  SkyList *skylist = SkyListByBounds (sky, -1, UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
     56  client_logger_message ("prepare to load catalogs\n");
    5557
    5658  /* load catalog data from region files (hostID is 0 since we are not a client */

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

    r38471 r38986  
    7171    // but it would be better to define a dvo crawler program to do this
    7272    // catalog.catformat = DVO_FORMAT_PS1_V1; 
    73     dvo_catalog_save (&catalog, VERBOSE);
    74     dvo_catalog_unlock (&catalog);
     73    SetProtect (TRUE);
     74    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     75    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     76    SetProtect (FALSE);
    7577    dvo_catalog_free (&catalog);
    7678  }

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

    r38923 r38986  
    5252  for (j = 0; j < catalog[Nc].Naverage; j++) {
    5353
    54     setMrelAverageExposure (&catalog[Nc], Nc, j, Nsecfilt, isSetMrelFinal, flatcorr, results);
     54    if (STAGES & STAGE_CHIP) {
     55      setMrelAverageExposure (&catalog[Nc], Nc, j, Nsecfilt, isSetMrelFinal, flatcorr, results);
     56    }
    5557
    5658    // only apply Stack operation on setMrelFinal in first pass
    57     if (isSetMrelFinal && !IS_DIFF_DB) {
     59    if (isSetMrelFinal && (STAGES & STAGE_STACK) && !IS_DIFF_DB) {
    5860      setMrelAverageStack (&catalog[Nc], Nc, j, Nsecfilt, flatcorr);
    5961    }
    6062
    6163    // only measure force-warp mean values if issetMrelFinal (make it optional?)
    62     if (isSetMrelFinal) {
     64    if (isSetMrelFinal && (STAGES & STAGE_WARP)) {
    6365      setMrelAverageForcedWarp (&catalog[Nc], Nc, j, Nsecfilt, flatcorr, results);
    6466    }

  • trunk/Ohana/src/tools/Makefile

    r37041 r38986  
    1515DVO_INCS  = $(DESTINC)/dvo.h $(DESTINC)/gfitsio.h $(DESTINC)/ohana.h $(DESTINC)/autocode.h
    1616
    17 PROGRAMS = gconfig fhead ftable fields list_astro glockfile \
     17PROGRAMS = gconfig fhead pspsconvert ftable fields list_astro glockfile \
    1818radec mktemp precess csystem fits_insert \
    19 medianfilter mefhead ckfits roc random
     19medianfilter mefhead ckfits roc random fits_to_mysql
    2020
    2121all tools: $(PROGRAMS)

  • trunk/Ohana/src/uniphot/Makefile

    r38464 r38986  
    6767$(SRC)/update_dvo_setphot.$(ARCH).o \
    6868$(SRC)/update_catalog_setphot.$(ARCH).o \
     69$(SRC)/repair_catalog_by_objID.$(ARCH).o \
    6970$(SRC)/SetSignals.$(ARCH).o         \
    7071$(SRC)/Shutdown.$(ARCH).o           
    … …  
    7778$(SRC)/update_dvo_setphot.$(ARCH).o \
    7879$(SRC)/update_catalog_setphot.$(ARCH).o \
     80$(SRC)/repair_catalog_by_objID.$(ARCH).o \
    7981$(SRC)/initialize_setphot_client.$(ARCH).o \
     82$(SRC)/SetSignals.$(ARCH).o         \
     83$(SRC)/Shutdown.$(ARCH).o           \
    8084$(SRC)/ImageSubset.$(ARCH).o
    8185
    … …  
    136140$(SRC)/repair_tycho_setastrom.$(ARCH).o \
    137141$(SRC)/astrom_correction.$(ARCH).o \
     142$(SRC)/SetSignals.$(ARCH).o         \
     143$(SRC)/Shutdown.$(ARCH).o           \
    138144$(SRC)/initialize_setastrom.$(ARCH).o
    139145
    … …  
    158164$(SRC)/update_catalog_setgalmodel.$(ARCH).o \
    159165$(SRC)/galmodel_correction.$(ARCH).o \
     166$(SRC)/SetSignals.$(ARCH).o         \
     167$(SRC)/Shutdown.$(ARCH).o           \
    160168$(SRC)/initialize_setgalmodel.$(ARCH).o
    161169
    … …  
    234242$(SRC)/initialize_ckids.$(ARCH).o     \
    235243$(SRC)/update_dvo_ckids.$(ARCH).o     \
     244$(SRC)/SetSignals.$(ARCH).o         \
     245$(SRC)/Shutdown.$(ARCH).o           \
    236246$(SRC)/update_catalog_ckids.$(ARCH).o
    237247
    … …  
    243253$(SRC)/initialize_ckids.$(ARCH).o     \
    244254$(SRC)/update_dvo_ckids.$(ARCH).o     \
     255$(SRC)/SetSignals.$(ARCH).o         \
     256$(SRC)/Shutdown.$(ARCH).o           \
    245257$(SRC)/update_catalog_ckids.$(ARCH).o
    246258

  • trunk/Ohana/src/uniphot/include/ckids.h

    r35764 r38986  
    2222void          ConfigInit                        PROTO((int *argc, char **argv));
    2323
    24 void          usage_ckids                       PROTO(());
     24void          usage_ckids                       PROTO((void));
    2525void          initialize_ckids                  PROTO((int argc, char **argv));
    2626int           args_ckids                        PROTO((int argc, char **argv));
    2727                                                   
    28 void          usage_ckids_client                PROTO(());
     28void          usage_ckids_client                PROTO((void));
    2929void          initialize_ckids_client           PROTO((int argc, char **argv));
    3030int           args_ckids_client                 PROTO((int argc, char **argv));
    3131
    32 int           update_dvo_ckids                  PROTO(());
     32int           update_dvo_ckids                  PROTO((void));
    3333int           update_dvo_ckids_parallel         PROTO((SkyList *sky));
    3434                                                   
    3535void          update_catalog_ckids              PROTO((Catalog *catalog, FILE *foutput));
     36
     37int           Shutdown                        PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2) );
     38void          TrapSignal                      PROTO((int sig));
     39void          SetProtect                      PROTO((int mode));
     40int           SetSignals                      PROTO((void));
     41

  • trunk/Ohana/src/uniphot/include/fiximids.h

    r35764 r38986  
    3737void          ConfigInit                        PROTO((int *argc, char **argv));
    3838
    39 void          usage_fiximids                    PROTO(());
     39void          usage_fiximids                    PROTO((void));
    4040void          initialize_fiximids               PROTO((int argc, char **argv));
    4141int           args_fiximids                     PROTO((int argc, char **argv));
    4242                                               
    43 void          usage_fiximids_client             PROTO(());
     43void          usage_fiximids_client             PROTO((void));
    4444void          initialize_fiximids_client        PROTO((int argc, char **argv));
    4545int           args_fiximids_client              PROTO((int argc, char **argv));

  • trunk/Ohana/src/uniphot/include/fixstkids.h

    r35764 r38986  
    3434void          ConfigInit                        PROTO((int *argc, char **argv));
    3535
    36 void          usage_fixstkids                   PROTO(());
     36void          usage_fixstkids                   PROTO((void));
    3737void          initialize_fixstkids              PROTO((int argc, char **argv));
    3838int           args_fixstkids                    PROTO((int argc, char **argv));
    3939                                               
    40 void          usage_fixstkids_client            PROTO(());
     40void          usage_fixstkids_client            PROTO((void));
    4141void          initialize_fixstkids_client       PROTO((int argc, char **argv));
    4242int           args_fixstkids_client             PROTO((int argc, char **argv));

  • trunk/Ohana/src/uniphot/include/setastrom.h

    r38464 r38986  
    6464void          ConfigInit                      PROTO((int *argc, char **argv));
    6565
    66 void          usage_setastrom                 PROTO(());
     66void          usage_setastrom                 PROTO((void));
    6767void          initialize_setastrom            PROTO((int argc, char **argv));
    6868int           args_setastrom                  PROTO((int argc, char **argv));
    6969
    70 void          usage_setastrom_client          PROTO(());
     70void          usage_setastrom_client          PROTO((void));
    7171void          initialize_setastrom_client     PROTO((int argc, char **argv));
    7272int           args_setastrom_client           PROTO((int argc, char **argv));
    7373
    74 // int           Shutdown                        PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2) );
    75 // void          TrapSignal                      PROTO((int sig));
    76 // void          SetProtect                      PROTO((int mode));
    77 // int           SetSignals                      PROTO((void));
     74int           Shutdown                        PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2) );
     75void          TrapSignal                      PROTO((int sig));
     76void          SetProtect                      PROTO((int mode));
     77int           SetSignals                      PROTO((void));
    7878
    79 int           update_dvo_setastrom            PROTO(());
     79int           update_dvo_setastrom            PROTO((void));
    8080int           update_dvo_setastrom_parallel   PROTO((SkyTable *sky));
    8181

  • trunk/Ohana/src/uniphot/include/setgalmodel.h

    r37807 r38986  
    2626void          ConfigInit                      PROTO((int *argc, char **argv));
    2727
    28 void          usage_setgalmodel                 PROTO(());
     28void          usage_setgalmodel                 PROTO((void));
    2929void          initialize_setgalmodel            PROTO((int argc, char **argv));
    3030int           args_setgalmodel                  PROTO((int argc, char **argv));
    3131
    32 void          usage_setgalmodel_client          PROTO(());
     32void          usage_setgalmodel_client          PROTO((void));
    3333void          initialize_setgalmodel_client     PROTO((int argc, char **argv));
    3434int           args_setgalmodel_client           PROTO((int argc, char **argv));
    3535
    36 // int           Shutdown                        PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2) );
    37 // void          TrapSignal                      PROTO((int sig));
    38 // void          SetProtect                      PROTO((int mode));
    39 // int           SetSignals                      PROTO((void));
     36int           Shutdown                        PROTO((char *format, ...) OHANA_FORMAT(printf, 1, 2) );
     37void          TrapSignal                      PROTO((int sig));
     38void          SetProtect                      PROTO((int mode));
     39int           SetSignals                      PROTO((void));
    4040
    4141int           update_dvo_setgalmodel            PROTO((void));

  • trunk/Ohana/src/uniphot/include/setphot.h

    r35103 r38986  
    3535int          PARALLEL_SERIAL;
    3636int          IMAGES_ONLY;
     37int          REPAIR_BY_OBJID;
    3738
    3839SkyRegion    UserPatch;
    … …  
    7677int           parse_zpt_offsets           PROTO((char *ZPT_OFFSET_FILTERS, char *ZPT_OFFSET_VALUES));
    7778float         apply_zpt_offset            PROTO((short code));
     79
     80int repair_catalog_by_objID (Catalog *catalog);

  • trunk/Ohana/src/uniphot/include/setposangle.h

    r35103 r38986  
    3939void          ConfigInit                        PROTO((int *argc, char **argv));
    4040
    41 void          usage_setposangle                 PROTO(());
     41void          usage_setposangle                 PROTO((void));
    4242void          initialize_setposangle            PROTO((int argc, char **argv));
    4343int           args_setposangle                  PROTO((int argc, char **argv));
    4444
    45 void          usage_setposangle_client          PROTO(());
     45void          usage_setposangle_client          PROTO((void));
    4646void          initialize_setposangle_client     PROTO((int argc, char **argv));
    4747int           args_setposangle_client           PROTO((int argc, char **argv));

  • trunk/Ohana/src/uniphot/src/Shutdown.c

    r27790 r38986  
    2121  va_end (argp);
    2222
    23   SetProtect (TRUE);
    24   gfits_db_close (db);
    2523  fprintf (stderr, "ERROR: halted\n");
    2624  exit (1);

  • trunk/Ohana/src/uniphot/src/ckids.c

    r35764 r38986  
    66
    77  /* get configuration info, args, lockfile */
     8  SetSignals ();
    89  initialize_ckids (argc, argv);
    910

  • trunk/Ohana/src/uniphot/src/ckids_client.c

    r35764 r38986  
    1212
    1313  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, IMAGES)
     14  SetSignals ();
    1415  initialize_ckids_client (argc, argv);
    1516

  • trunk/Ohana/src/uniphot/src/fiximids.c

    r38441 r38986  
    88
    99  /* get configuration info, args, lockfile */
     10  SetSignals ();
    1011  initialize_fiximids (argc, argv);
    1112

  • trunk/Ohana/src/uniphot/src/fiximids_client.c

    r35764 r38986  
    1313
    1414  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, IMAGES)
     15  SetSignals ();
    1516  initialize_fiximids_client (argc, argv);
    1617

  • trunk/Ohana/src/uniphot/src/fixstkids.c

    r38441 r38986  
    88
    99  /* get configuration info, args, lockfile */
     10  SetSignals ();
    1011  initialize_fixstkids (argc, argv);
    1112

  • trunk/Ohana/src/uniphot/src/fixstkids_client.c

    r35764 r38986  
    1313
    1414  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, IMAGES)
     15  SetSignals ();
    1516  initialize_fixstkids_client (argc, argv);
    1617

  • trunk/Ohana/src/uniphot/src/initialize_setphot.c

    r35103 r38986  
    4949  if ((N = get_argument (argc, argv, "-reset"))) {
    5050    RESET = TRUE;
     51    remove_argument (N, &argc, argv);
     52  }
     53
     54  REPAIR_BY_OBJID = FALSE;
     55  if ((N = get_argument (argc, argv, "-repair-by-objid"))) {
     56    REPAIR_BY_OBJID = TRUE;
    5157    remove_argument (N, &argc, argv);
    5258  }

  • trunk/Ohana/src/uniphot/src/initialize_setphot_client.c

    r35103 r38986  
    5353    remove_argument (N, &argc, argv);
    5454    UserPatch.Dmax = atof (argv[N]);
     55    remove_argument (N, &argc, argv);
     56  }
     57
     58  REPAIR_BY_OBJID = FALSE;
     59  if ((N = get_argument (argc, argv, "-repair-by-objid"))) {
     60    REPAIR_BY_OBJID = TRUE;
    5561    remove_argument (N, &argc, argv);
    5662  }

  • trunk/Ohana/src/uniphot/src/load_zpt_table.c

    r37807 r38986  
    107107  if (NO_METADATA) {
    108108    NFILTER = 5;
    109     NSEASON = 4;
     109    NSEASON = 5;
    110110    NCHIP_X = 8;
    111111    NCHIP_Y = 8;
    … …  
    165165  // ubercal hard-coded values
    166166  char filters_uc[5][3] = {"g", "r", "i", "z", "y"};
    167   double tstart_uc[] = {55000.0, 55296.0, 55327.0, 55662.0};
    168   double tstop_uc[]  = {55296.0, 55327.0, 55662.0, 60000.0};
     167
     168  // double tstart_uc[] = {55000.0, 55296.0, 55327.0, 55662.0};
     169  // double tstop_uc[]  = {55296.0, 55327.0, 55662.0, 60000.0};
     170
     171  double tstart_uc[] = {50000.0, 55296.0, 55327.0, 55662.0, 56110.0};
     172  double tstop_uc[]  = {55296.0, 55327.0, 55662.0, 56110.0, 65000.0};
    169173
    170174  double mjdstart, mjdstop;
    … …  
    275279        exit (2);
    276280    }
     281
     282    // ***** skip the extra table segment *****
     283    // load data for this header
     284    if (!gfits_load_header (f, &theader)) return (NULL);
     285
     286    // read the fits table bytes
     287    if (!gfits_fread_ftable_data (f, &ftable, FALSE)) return (NULL);
     288 
     289    // skip over remaining bytes in data segment
     290    fseeko (f, ftable.datasize - ftable.validsize, SEEK_CUR);
    277291
    278292    // XXX the initial hacked-together table from Eddie is missing the last 2 elements.  they should be zero

  • trunk/Ohana/src/uniphot/src/setastrom.c

    r38464 r38986  
    66
    77  /* get configuration info, args, lockfile */
     8  SetSignals ();
    89  initialize_setastrom (argc, argv);
    910

  • trunk/Ohana/src/uniphot/src/setastrom_client.c

    r35103 r38986  
    1313
    1414  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, IMAGES)
     15  SetSignals ();
    1516  initialize_setastrom_client (argc, argv);
    1617
    17   update_dvo_setastrom (argv[1]);
     18  update_dvo_setastrom ();
    1819
    1920  exit (0);

  • trunk/Ohana/src/uniphot/src/setfwhm.c

    r38441 r38986  
    1010
    1111  /* get configuration info, args, lockfile */
     12  SetSignals ();
    1213  initialize_setfwhm (argc, argv);
    1314

  • trunk/Ohana/src/uniphot/src/setgalmodel.c

    r37807 r38986  
    66
    77  /* get configuration info, args, lockfile */
     8  SetSignals ();
    89  initialize_setgalmodel (argc, argv);
    910

  • trunk/Ohana/src/uniphot/src/setgalmodel_client.c

    r37807 r38986  
    1313
    1414  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, IMAGES)
     15  SetSignals ();
    1516  initialize_setgalmodel_client (argc, argv);
    1617

  • trunk/Ohana/src/uniphot/src/setphot.c

    r38464 r38986  
    1111
    1212  /* get configuration info, args, lockfile */
     13  SetSignals ();
    1314  initialize_setphot (argc, argv);
    1415
    … …  
    5051  // write image table (even if some remote clients failed)
    5152  if (UPDATE) {
     53    SetProtect (TRUE);
    5254    dvo_image_save (&db, VERBOSE);
     55    SetProtect (FALSE);
    5356  }
    5457

  • trunk/Ohana/src/uniphot/src/setphot_client.c

    r33654 r38986  
    1313
    1414  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, IMAGES)
     15  SetSignals ();
    1516  initialize_setphot_client (argc, argv);
    1617

  • trunk/Ohana/src/uniphot/src/setposangle.c

    r38441 r38986  
    88
    99  /* get configuration info, args, lockfile */
     10  SetSignals ();
    1011  initialize_setposangle (argc, argv);
    1112

  • trunk/Ohana/src/uniphot/src/setposangle_client.c

    r34749 r38986  
    1313
    1414  // get configuration info, args, lockfile (set CATDIR, HOST_ID, HOSTDIR, IMAGES)
     15  SetSignals ();
    1516  initialize_setposangle_client (argc, argv);
    1617

  • trunk/Ohana/src/uniphot/src/uniphot.c

    r38441 r38986  
    1616
    1717  /* get configuration info, args, lockfile */
     18  SetSignals ();
    1819  initialize_uniphot (argc, argv);
    1920

  • trunk/Ohana/src/uniphot/src/update_catalog_setastrom.c

    r38062 r38986  
    4242    // XXX hardwire the list of chips to KH correct
    4343    // some notes:
     44    // XY17 surprisingly does not need correction
    4445    // XY24 surprisingly does not need correction
    45     // XY27 has poor astrometry with a weird correction for all mags
    4646    // XY36 surprisingly does not need correction
    47     // XY67 has poor astrometry with a weird correction for all mags
    4847
    4948    int doKH = FALSE;
    … …  
    5554      case 15:
    5655      case 16:
    57       case 17:
    5856      case 25:
    5957      case 26:
     58      case 27:
    6059      case 34:
    6160      case 35:
    … …  
    7372      case 62:
    7473      case 63:
     74      case 67:
    7575      case 71:
    7676      case 72:
    … …  
    100100      // this correction here (but ideally I would re-measure the KH trend from PV2 data and re-generate
    101101      // the splines
    102       float MinstSB = Minst + 5.0*log10(M_SQRT2*fwhm_maj);
     102      float MinstSB = Minst + 5.0*log10(fwhm_maj);
    103103
    104104      // I should validate that the spline I'm using is SB corrected not Minst..
    … …  
    249249    // do not modify the original Xccd,Yccd values
    250250    if (KH_FILE) {
    251       measure[0].XoffKH = dX_KH / pltScale;
    252       measure[0].YoffKH = dY_KH / pltScale;
     251      measure[0].XoffKH = -dX_KH / pltScale;
     252      measure[0].YoffKH = -dY_KH / pltScale;
    253253    }
    254254    if (KH_RESET) {

  • trunk/Ohana/src/uniphot/src/update_catalog_setgalmodel.c

    r37807 r38986  
    33int update_catalog_setgalmodel (Catalog *catalog) {
    44
    5   off_t i, j, m;
    6 
    7   // choose this number more judiciously...
    8   time_t timeRef = ohana_date_to_sec("2000/01/01,00:00:00");
     5  off_t i, m;
    96
    107  Average *average = catalog[0].average;
    … …  
    2017  for (i = 0; i < catalog[0].Naverage; i++) {
    2118
    22     {
    23       m = average[i].measureOffset;
    24       Measure *measure = &catalog[0].measure[m];
    25       for (j = 0; j < average[i].Nmeasure; j++) {
    26         measure[j].RoffGAL = 0.0; // XXX divide by dcos? project and calculate?
    27         measure[j].DoffGAL = 0.0; // XXX divide by dcos? project and calculate?
    28       }
    29     }
     19    average[i].uRgal = NAN;
     20    average[i].uDgal = NAN;
    3021
    3122    if (average[i].Nstarpar == 0) continue;
    … …  
    6354    starpar->uDEC = uD;
    6455
    65     m = average[i].measureOffset;
    66     Measure *measure = &catalog[0].measure[m];
    67 
    68     // use the model uR,uD values to move the expected position based on the reference date;
    69     for (j = 0; j < average[i].Nmeasure; j++) {
    70 
    71       double dtime = (measure[j].t - timeRef) / 86400.0 / 365.25;
    72 
    73       // do not modify the original Xccd,Yccd values
    74       measure[j].RoffGAL = uR * dtime; // XXX divide by dcos? project and calculate?
    75       measure[j].DoffGAL = uD * dtime; // XXX divide by dcos? project and calculate?
    76     }
     56    average[i].uRgal = uR;
     57    average[i].uDgal = uD;
    7758  }
    7859

  • trunk/Ohana/src/uniphot/src/update_dvo_ckids.c

    r38471 r38986  
    6969    if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
    7070   
    71     dvo_catalog_save (&catalog, VERBOSE);
    72     dvo_catalog_unlock (&catalog);
     71    SetProtect (TRUE);
     72    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     73    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     74    SetProtect (FALSE);
    7375    dvo_catalog_free (&catalog);
    7476  }

  • trunk/Ohana/src/uniphot/src/update_dvo_fiximids.c

    r38471 r38986  
    6464    if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
    6565   
    66     dvo_catalog_save (&catalog, VERBOSE);
    67     dvo_catalog_unlock (&catalog);
     66    SetProtect (TRUE);
     67    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     68    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     69    SetProtect (FALSE);
    6870    dvo_catalog_free (&catalog);
    6971  }

  • trunk/Ohana/src/uniphot/src/update_dvo_fixstkids.c

    r38471 r38986  
    6464    if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
    6565   
    66     dvo_catalog_save (&catalog, VERBOSE);
    67     dvo_catalog_unlock (&catalog);
     66    SetProtect (TRUE);
     67    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     68    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     69    SetProtect (FALSE);
    6870    dvo_catalog_free (&catalog);
    6971  }

  • trunk/Ohana/src/uniphot/src/update_dvo_setastrom.c

    r38471 r38986  
    11# include "setastrom.h"
    22
    3 int update_dvo_setastrom () {
     3int update_dvo_setastrom (void) {
    44
    55  SkyTable *sky = NULL;
    … …  
    7474    if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
    7575   
    76     dvo_catalog_save (&catalog, VERBOSE);
    77     dvo_catalog_unlock (&catalog);
     76    struct timeval now;
     77    gettimeofday (&now, (void *) NULL);
     78    char *moddate = ohana_sec_to_date (now.tv_sec);
     79    gfits_modify (&catalog.header, "SETASTR", "%s", 1, moddate); // replaces the single entry
     80
     81    char history[128];
     82    snprintf (history, 128, "setastrom applied: %s", moddate);
     83    gfits_modify_alt (&catalog.header, "HISTORY", "%S", 0, history); // adds a new entry
     84
     85    snprintf (history, 128, "setastrom options: KH: %1d, DCR: %1d, CAM: %1d", (KH_FILE != NULL), (DCR_FILE != NULL), (CAM_FILE != NULL));
     86    gfits_modify_alt (&catalog.header, "HISTORY", "%S", 0, history); // adds a new entry
     87
     88    SetProtect (TRUE);
     89    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     90    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     91    SetProtect (FALSE);
    7892    dvo_catalog_free (&catalog);
    7993  }

  • trunk/Ohana/src/uniphot/src/update_dvo_setgalmodel.c

    r38471 r38986  
    6666    if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
    6767   
    68     dvo_catalog_save (&catalog, VERBOSE);
    69     dvo_catalog_unlock (&catalog);
     68    SetProtect (TRUE);
     69    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     70    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     71    SetProtect (FALSE);
    7072    dvo_catalog_free (&catalog);
    7173  }

  • trunk/Ohana/src/uniphot/src/update_dvo_setphot.c

    r38471 r38986  
    5353    dvo_catalog_init (&catalog, TRUE);
    5454    catalog.filename    = HOST_ID ? localFilename : skylist[0].filename[i];
    55     catalog.catflags    = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE | DVO_LOAD_MISSING | DVO_LOAD_SECFILT;
     55    catalog.catflags    = DVO_LOAD_AVERAGE | DVO_LOAD_MEASURE;
    5656    catalog.Nsecfilt    = GetPhotcodeNsecfilt ();
    5757
    … …  
    6767    }
    6868
     69    if (REPAIR_BY_OBJID) {
     70      // For gpc1 / PV3, I broke some catalogs with dvomerge -replace: the last object can
     71      // contaminate the first set of new measurements
     72      repair_catalog_by_objID (&catalog);
     73    }
     74
    6975    update_catalog_setphot (&catalog, image, index, Nimage, flatcorr);
    7076
    … …  
    7783    if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
    7884   
    79     dvo_catalog_save (&catalog, VERBOSE);
    80     dvo_catalog_unlock (&catalog);
     85    struct timeval now;
     86    gettimeofday (&now, (void *) NULL);
     87    char *moddate = ohana_sec_to_date (now.tv_sec);
     88    gfits_modify (&catalog.header, "SETPHOT", "%s", 1, moddate); // replaces the single entry
     89
     90    char history[128];
     91    snprintf (history, 128, "setphot applied: %s", moddate);
     92    gfits_modify_alt (&catalog.header, "HISTORY", "%S", 0, history); // adds a new entry
     93
     94    snprintf (history, 128, "setphot options: reset: %1d, ubercal: %1d", RESET, UBERCAL);
     95    gfits_modify_alt (&catalog.header, "HISTORY", "%S", 0, history); // adds a new entry
     96
     97    free (moddate);
     98
     99    SetProtect (TRUE);
     100    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     101    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     102    SetProtect (FALSE);
    81103    dvo_catalog_free (&catalog);
    82104  }
    … …  
    114136              UserPatch.Rmin, UserPatch.Rmax, UserPatch.Dmin, UserPatch.Dmax);
    115137
    116     if (VERBOSE)       { strextend (&command, "-v"); }
    117     if (RESET)         { strextend (&command, "-reset"); }
    118     if (UPDATE)        { strextend (&command, "-update"); }
    119     if (UBERCAL)       { strextend (&command, "-ubercal"); }
     138    if (VERBOSE)         { strextend (&command, "-v"); }
     139    if (RESET)           { strextend (&command, "-reset"); }
     140    if (UPDATE)          { strextend (&command, "-update"); }
     141    if (UBERCAL)         { strextend (&command, "-ubercal"); }
     142    if (REPAIR_BY_OBJID) { strextend (&command, "-repair-by-objid"); }
    120143
    121144    fprintf (stderr, "command: %s\n", command);

  • trunk/Ohana/src/uniphot/src/update_dvo_setposangle.c

    r38471 r38986  
    7878    if (VERBOSE) fprintf (stderr, "saving catalog %s\n", catalog.filename);
    7979   
    80     dvo_catalog_save (&catalog, VERBOSE);
    81     dvo_catalog_unlock (&catalog);
     80    SetProtect (TRUE);
     81    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     82    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     83    SetProtect (FALSE);
    8284    dvo_catalog_free (&catalog);
    8385  }

  • trunk/Ohana/src/uniphot/src/update_dvo_uniphot.c

    r38471 r38986  
    101101    fprintf (stderr, "catalog: %s sgroup: %d %s %f\n", catalog.filename, Nmin, sgroup[Nmin].label, Rmin);
    102102    update_catalog_uniphot (&catalog, &sgroup[Nmin], (Rmin > 2*RADIUS));
    103     dvo_catalog_save (&catalog, VERBOSE);
    104     dvo_catalog_unlock (&catalog);
     103    SetProtect (TRUE);
     104    if (!dvo_catalog_save (&catalog, VERBOSE)) { fprintf (stderr, "ERROR: failed to save %s\n", catalog.filename); exit (1); }
     105    if (!dvo_catalog_unlock (&catalog)) { fprintf (stderr, "ERROR: failed to unlock %s\n", catalog.filename); exit (1); }
     106    SetProtect (FALSE);
    105107    dvo_catalog_free (&catalog);
    106108  }
Note: See TracChangeset for help on using the changeset viewer.