IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 16633


Ignore:
Timestamp:
Feb 23, 2008, 3:16:39 PM (18 years ago)
Author:
eugene
Message:

rename of average elements Nm,Nn,offset,missing to Nmeasure, Nmissing, measureOffset, missingOffset

Location:
branches/eam_branch_20080223/Ohana/src
Files:
51 edited

Legend:

Unmodified
Added
Removed

  • branches/eam_branch_20080223/Ohana/src/addstar/src/SEDfit.c

    r15743 r16633  
    7777
    7878    // load the measurements for this source
    79     m = incat[0].average[i].offset;
     79    m = incat[0].average[i].measureOffset;
    8080    Nphot = 0;
    81     for (j = 0; j < incat[0].average[i].Nm; j++) {
     81    for (j = 0; j < incat[0].average[i].Nmeasure; j++) {
    8282      idx = table[0].hashcode[incat[0].measure[m+j].photcode];
    8383      if (idx == -1) continue;
    … …  
    159159
    160160    // XXX for now, set the average mag data to NULL
    161     outcat[0].average[Nave].Nm        = 0;
    162     outcat[0].average[Nave].Nn        = 0;
    163     outcat[0].average[Nave].Xp        = NAN_S_SHORT;
    164     outcat[0].average[Nave].offset    = Nmeas;
    165     outcat[0].average[Nave].missing  = -1;
    166     outcat[0].average[Nave].code      = 0;
     161    outcat[0].average[Nave].Nmeasure      = 0;
     162    outcat[0].average[Nave].Nmissing      = 0;
     163    outcat[0].average[Nave].Xp            = NAN_S_SHORT;
     164    outcat[0].average[Nave].measureOffset = Nmeas;
     165    outcat[0].average[Nave].missingOffset = -1;
     166    outcat[0].average[Nave].code          = 0;
    167167
    168168    for (j = 0; j < Nsec; j++) {
    … …  
    199199      outcat[0].measure[Nmeas].theta    = NAN_S_SHORT;
    200200
    201       outcat[0].average[Nave].Nm++;
     201      outcat[0].average[Nave].Nmeasure++;
    202202      Nmeas ++;
    203203    }

  • branches/eam_branch_20080223/Ohana/src/addstar/src/build_links.c

    r5239 r16633  
    22
    33/* build the initial links assuming the table is sorted,
    4    not partial, and has a correct set of average[].offset,Nm values */
     4   not partial, and has a correct set of average[].measureOffset,Nm values */
    55int *init_measure_links (Average *average, int Naverage, Measure *measure, int Nmeasure) {
    66
    … …  
    1212  ALLOCATE (next, int, Nmeasure);
    1313  for (i = 0; i < Naverage; i++, N++) {
    14     for (j = 0; j < average[i].Nm - 1; j++, N++) {
     14    for (j = 0; j < average[i].Nmeasure - 1; j++, N++) {
    1515      next[N] = N + 1;
    1616      if (N >= Nmeasure) {
    … …  
    4141  ALLOCATE (next, int, Nmissing);
    4242  for (i = 0; i < Naverage; i++) {
    43     for (j = 0; j < average[i].Nn - 1; j++, N++) {
     43    for (j = 0; j < average[i].Nmissing - 1; j++, N++) {
    4444      next[N] = N + 1;
    4545    }
    46     if (average[i].Nn > 0) {
     46    if (average[i].Nmissing > 0) {
    4747      next[N] = -1;
    4848      if (N >= Nmissing) {
    … …  
    5757}
    5858
    59 /* average[].offset, average[].Nm are valid within an addstar run */
     59/* average[].measureOffset, average[].Nmeasure are valid within an addstar run */
    6060int add_meas_link (Average *average, int *next, int Nmeasure, int NMEASURE) {
    6161
    … …  
    6363
    6464  /* if we have trouble, check validity of next[m] : m < Nmeasure */
    65   m = average[0].offset; 
    66 
    67   for (k = 0; k < average[0].Nm - 1; k++)  {
     65  m = average[0].measureOffset; 
     66
     67  for (k = 0; k < average[0].Nmeasure - 1; k++)  {
    6868    m = next[m];
    6969    if (m >= NMEASURE) {
    … …  
    7979
    8080  if (m == -1) {
    81     average[0].offset = Nmeasure;
     81    average[0].measureOffset = Nmeasure;
    8282  } else {
    8383    next[m] = Nmeasure;
    … …  
    9595
    9696  /* there may be 0 Nmiss; this is not true for Nmeas */
    97   if (average[0].Nn < 1) {
    98     average[0].missing = Nmissing;
     97  if (average[0].Nmissing < 1) {
     98    average[0].missingOffset = Nmissing;
    9999    next[Nmissing] = -1;
    100100    return (TRUE);
    101101  }
    102102
    103   m = average[0].missing; 
    104   for (k = 0; k < average[0].Nn - 1; k++) m = next[m];
     103  m = average[0].missingOffset; 
     104  for (k = 0; k < average[0].Nmissing - 1; k++) m = next[m];
    105105  /* set up references */
    106106  next[Nmissing] = -1;
    … …  
    125125  /* reset the Nm, offset values for average */
    126126  for (i = 0; i < Naverage; i++) {
    127     average[i].offset = -1;
    128     average[i].Nm     =  0;
     127    average[i].measureOffset = -1;
     128    average[i].Nmeasure     =  0;
    129129  }
    130130
    131131  for (Nm = 0; Nm < Nmeasure; Nm++) {
    132132    averef = measure[Nm].averef;
    133     m = average[averef].offset; 
     133    m = average[averef].measureOffset; 
    134134    next[Nm] = -1;
    135135
    136136    if (m == -1) { /* no links yet for source */
    137       average[averef].offset = Nm;
    138       average[averef].Nm     = 1;
     137      average[averef].measureOffset = Nm;
     138      average[averef].Nmeasure     = 1;
    139139      continue;
    140140    }
    … …  
    147147    }
    148148
    149     average[averef].Nm = k + 2;
     149    average[averef].Nmeasure = k + 2;
    150150    next[m] = Nm;
    151151    if (m >= Nmeasure) {
    … …  
    168168  ALLOCATE (tmpmeasure, Measure, Nmeasure);
    169169  for (i = 0; i < Naverage; i++) {
    170     n = average[i].offset;
    171     average[i].offset = N;
    172     for (k = 0; k < average[i].Nm; k++, N++) {
     170    n = average[i].measureOffset;
     171    average[i].measureOffset = N;
     172    for (k = 0; k < average[i].Nmeasure; k++, N++) {
    173173      tmpmeasure[N] = measure[n];
    174174      tmpmeasure[N].averef = i;
    … …  
    189189  ALLOCATE (tmpmissing, Missing, Nmissing);
    190190  for (i = 0; i < Naverage; i++) {
    191     n = average[i].missing;
    192     average[i].missing = N;
    193     for (k = 0; k < average[i].Nn; k++, N++) {
     191    n = average[i].missingOffset;
     192    average[i].missingOffset = N;
     193    for (k = 0; k < average[i].Nmissing; k++, N++) {
    194194      tmpmissing[N] = missing[n];
    195195      n = next[n];

  • branches/eam_branch_20080223/Ohana/src/addstar/src/calibrate.c

    r16040 r16633  
    9797  }
    9898
    99   m = average[0].offset;
    100   for (i = 0; i < average[0].Nm; i++) {
     99  m = average[0].measureOffset;
     100  for (i = 0; i < average[0].Nmeasure; i++) {
    101101    if (measure[m].photcode == CalC0) {
    102102      found0 = TRUE;

  • branches/eam_branch_20080223/Ohana/src/addstar/src/find_matches.c

    r16040 r16633  
    233233      /* Nm is updated, but not written out in -update mode (for existing entries)
    234234         Nm is recalculated in build_meas_links if loaded table is not sorted */
    235       catalog[0].average[n].Nm ++;
     235      catalog[0].average[n].Nmeasure ++;
    236236      Nmeas ++;
    237237
    … …  
    263263    if (!IN_REGION (stars[N].R, stars[N].D)) continue;
    264264
    265     catalog[0].average[Nave].R         = stars[N].R;
    266     catalog[0].average[Nave].D         = stars[N].D;
    267     catalog[0].average[Nave].Xp        = 0;
    268     catalog[0].average[Nave].Nm        = 1;
    269     catalog[0].average[Nave].Nn        = 0;
    270     catalog[0].average[Nave].offset    = Nmeas;
    271     catalog[0].average[Nave].missing  = -1;
    272     catalog[0].average[Nave].code      = 0;
     265    catalog[0].average[Nave].R             = stars[N].R;
     266    catalog[0].average[Nave].D             = stars[N].D;
     267    catalog[0].average[Nave].Xp            = 0;
     268    catalog[0].average[Nave].Nmeasure      = 1;
     269    catalog[0].average[Nave].Nmissing      = 0;
     270    catalog[0].average[Nave].measureOffset = Nmeas;
     271    catalog[0].average[Nave].missingOffset = -1;
     272    catalog[0].average[Nave].code          = 0;
    273273
    274274    catalog[0].average[Nave].dR        = 0;

  • branches/eam_branch_20080223/Ohana/src/addstar/src/find_matches_closest.c

    r16040 r16633  
    241241    stars[N].found = Nmeas;
    242242    catalog[0].found[n] = Nmeas;
    243     catalog[0].average[n].Nm ++;
     243    catalog[0].average[n].Nmeasure ++;
    244244    Nmeas ++;
    245245    i++;
    … …  
    265265    if (!IN_REGION (stars[N].R, stars[N].D)) continue;
    266266
    267     catalog[0].average[Nave].R         = stars[N].R;
    268     catalog[0].average[Nave].D         = stars[N].D;
    269     catalog[0].average[Nave].Xp        = 0;
    270     catalog[0].average[Nave].Nm        = 1;
    271     catalog[0].average[Nave].Nn        = 0;
    272     catalog[0].average[Nave].offset    = Nmeas;
    273     catalog[0].average[Nave].missing  = -1;
    274     catalog[0].average[Nave].code      = 0;
     267    catalog[0].average[Nave].R             = stars[N].R;
     268    catalog[0].average[Nave].D             = stars[N].D;
     269    catalog[0].average[Nave].Xp            = 0;
     270    catalog[0].average[Nave].Nmeasure      = 1;
     271    catalog[0].average[Nave].Nmissing      = 0;
     272    catalog[0].average[Nave].measureOffset = Nmeas;
     273    catalog[0].average[Nave].missingOffset = -1;
     274    catalog[0].average[Nave].code          = 0;
    275275
    276276    catalog[0].average[Nave].dR        = 0;

  • branches/eam_branch_20080223/Ohana/src/addstar/src/find_matches_refstars.c

    r16040 r16633  
    115115      n = N2[J];
    116116      N = N1[i];
    117       m = catalog[0].average[n].offset; 
     117      m = catalog[0].average[n].measureOffset; 
    118118
    119119      /** in replace mode, search for entry and replace values M, dM, R, D */
    … …  
    122122      /** insert star in measurement list */
    123123      /* find last measurement of this star */
    124       for (k = 0; k < catalog[0].average[n].Nm - 1; k++) m = next[m];
     124      for (k = 0; k < catalog[0].average[n].Nmeasure - 1; k++) m = next[m];
    125125      /* set up references */
    126126      next[Nmeas] = next[m];
    … …  
    199199      }
    200200
    201       catalog[0].average[n].Nm ++;
     201      catalog[0].average[n].Nmeasure ++;
    202202      Nmeas ++;
    203203      if (Nmeas == NMEAS) {
    … …  
    224224    if (stars[N][0].found >= 0) continue;
    225225
    226     catalog[0].average[Nave].R         = stars[N][0].R;
    227     catalog[0].average[Nave].D         = stars[N][0].D;
    228     catalog[0].average[Nave].Xp        = 0;
    229     catalog[0].average[Nave].Nm        = 1;
    230     catalog[0].average[Nave].Nn        = 0;
    231     catalog[0].average[Nave].offset    = Nmeas;
    232     catalog[0].average[Nave].missing  = -1;
    233     catalog[0].average[Nave].code      = 0;
     226    catalog[0].average[Nave].R             = stars[N][0].R;
     227    catalog[0].average[Nave].D             = stars[N][0].D;
     228    catalog[0].average[Nave].Xp            = 0;
     229    catalog[0].average[Nave].Nmeasure      = 1;
     230    catalog[0].average[Nave].Nmissing      = 0;
     231    catalog[0].average[Nave].measureOffset = Nmeas;
     232    catalog[0].average[Nave].missingOffset = -1;
     233    catalog[0].average[Nave].code          = 0;
    234234
    235235    if (ACCEPT_MOTION) {
    … …  
    324324  ALLOCATE (tmpmeasure, Measure, Nmeas);
    325325  for (i = 0; i < Nave; i++) {
    326     n = catalog[0].average[i].offset;
    327     catalog[0].average[i].offset = N;
    328     for (k = 0; k < catalog[0].average[i].Nm; k++, N++) {
     326    n = catalog[0].average[i].measureOffset;
     327    catalog[0].average[i].measureOffset = N;
     328    for (k = 0; k < catalog[0].average[i].Nmeasure; k++, N++) {
    329329      tmpmeasure[N] = catalog[0].measure[n];
    330330      tmpmeasure[N].averef = i;
    … …  
    339339  ALLOCATE (tmpmissing, Missing, Nmiss);
    340340  for (i = 0; i < Nave; i++) {
    341     if (catalog[0].average[i].Nn > 0) {
    342       n = catalog[0].average[i].missing;
    343       catalog[0].average[i].missing = N;
    344       for (k = 0; k < catalog[0].average[i].Nn; k++, N++) {
     341    if (catalog[0].average[i].Nmissing > 0) {
     342      n = catalog[0].average[i].missingOffset;
     343      catalog[0].average[i].missingOffset = N;
     344      for (k = 0; k < catalog[0].average[i].Nmissing; k++, N++) {
    345345        tmpmissing[N] = catalog[0].missing[n];
    346346        n = next_miss[n];

  • branches/eam_branch_20080223/Ohana/src/addstar/src/load2mass_catalog.c

    r15743 r16633  
    3232
    3333    // XXX for now, set the average mag data to NULL
    34     catalog[0].average[Nave].Nm        = 0;
    35     catalog[0].average[Nave].Nn        = 0;
    36     catalog[0].average[Nave].Xp        = NAN_S_SHORT;
    37     catalog[0].average[Nave].offset    = Nmeas;
    38     catalog[0].average[Nave].missing  = -1;
    39     catalog[0].average[Nave].code      = 0;
     34    catalog[0].average[Nave].Nmeasure      = 0;
     35    catalog[0].average[Nave].Nmissing      = 0;
     36    catalog[0].average[Nave].Xp            = NAN_S_SHORT;
     37    catalog[0].average[Nave].measureOffset = Nmeas;
     38    catalog[0].average[Nave].missingOffset = -1;
     39    catalog[0].average[Nave].code          = 0;
    4040
    4141    for (j = 0; j < Nsec; j++) {
    … …  
    6565      catalog[0].measure[Nmeas].theta    = NAN_S_SHORT;
    6666
    67       catalog[0].average[Nave].Nm++;
     67      catalog[0].average[Nave].Nmeasure++;
    6868      Nmeas ++;
    6969      CHECK_REALLOCATE (catalog[0].measure, Measure, NMEAS, Nmeas, 100);

  • branches/eam_branch_20080223/Ohana/src/addstar/src/replace_match.c

    r15509 r16633  
    66
    77  /* search for entry and replace values M, dM, R, D */
    8   for (i = 0; i < average[0].Nm; i++) {
     8  for (i = 0; i < average[0].Nmeasure; i++) {
    99    if (measure[i].photcode != star[0].code) continue;
    1010    measure[i].dR = 3600.0*(average[0].R - star[0].R);
    … …  
    1212    measure[i].M  = star[0].M;
    1313    measure[i].dM = star[0].dM;
    14     star[0].found = average[0].offset + i;
     14    star[0].found = average[0].measureOffset + i;
    1515    return (TRUE);
    1616  }

  • branches/eam_branch_20080223/Ohana/src/addstar/src/update_coords.c

    r12332 r16633  
    1010  Npt = r = d = r2 = d2 = 0;
    1111
    12   if (average[0].Nm < 2) return;
     12  if (average[0].Nmeasure < 2) return;
    1313
    1414  /* find the average & sum-square (does not use reference coordinates) */
    15   m = average[0].offset;  /* first measurement of this star */
    16   for (i = 0; i < average[0].Nm; i++) {
     15  m = average[0].measureOffset;  /* first measurement of this star */
     16  for (i = 0; i < average[0].Nmeasure; i++) {
    1717    if (measure[m].t == 0) {
    1818      m = next[m];
    … …  
    3535  average[0].R -= r / 3600.0;
    3636  average[0].D -= d / 3600.0;
    37   m = average[0].offset;  /* first measurement of this star */
    38   for (i = 0; i < average[0].Nm; i++) {
     37  m = average[0].measureOffset;  /* first measurement of this star */
     38  for (i = 0; i < average[0].Nmeasure; i++) {
    3939    measure[m].dR -= r;
    4040    measure[m].dD -= d;

  • branches/eam_branch_20080223/Ohana/src/delstar/src/find_matches.c

    r15743 r16633  
    3737  /* set up references for missing to average */
    3838  for (i = 0; i < Nave; i++) {
    39     for (j = 0; j < catalog[0].average[i].Nn; j++) {
    40       ave_miss[catalog[0].average[i].missing + j] = i;
     39    for (j = 0; j < catalog[0].average[i].Nmissing; j++) {
     40      ave_miss[catalog[0].average[i].missingOffset + j] = i;
    4141    }
    4242  }
    … …  
    8888    /*** fix the corresponding average entry ***/
    8989    n = catalog[0].measure[i].averef;
    90     if (catalog[0].average[n].Nm == 0) { /* this should never happen */
     90    if (catalog[0].average[n].Nmeasure == 0) { /* this should never happen */
    9191      fprintf (stderr, "error? we deleted one too many objects?\n");
    9292      exit (1);
    9393    }
    94     catalog[0].average[n].Nm --;
     94    catalog[0].average[n].Nmeasure --;
    9595    /* this was only entry in list: will be deleted below.  meanwhile, delete all missing entries*/
    96     if ((catalog[0].average[n].Nm < 1) && (catalog[0].average[n].Nn > 0)) {
    97       m = catalog[0].average[n].missing;
    98       for (j = 0; j < catalog[0].average[n].Nn; j++) {
     96    if ((catalog[0].average[n].Nmeasure < 1) && (catalog[0].average[n].Nmissing > 0)) {
     97      m = catalog[0].average[n].missingOffset;
     98      for (j = 0; j < catalog[0].average[n].Nmissing; j++) {
    9999        M = next_miss[m];
    100100        next_miss[m] = -2;
    101101        m = M;
    102102      }
    103       m = catalog[0].average[n].missing;
     103      m = catalog[0].average[n].missingOffset;
    104104      /* fix the list links: connect the previous valid link to the next valid link */
    105105      for (j = m; (j >= 0) && (next_miss[j] == -2); j--); /* find previous entry to fix link */
    … …  
    119119    }
    120120    /* this was first entry in list */
    121     if ((catalog[0].average[n].offset == i) && (catalog[0].average[n].Nm > 0)) {
    122       m = catalog[0].average[n].offset;
     121    if ((catalog[0].average[n].measureOffset == i) && (catalog[0].average[n].Nmeasure > 0)) {
     122      m = catalog[0].average[n].measureOffset;
    123123      /* find next valid entry -- notice lack of error checking... */
    124124      for (j = 0; (j < Nmeas) && (next[m+j] == -2); j++);
    125       catalog[0].average[n].offset = m + j;
     125      catalog[0].average[n].measureOffset = m + j;
    126126    }
    127127  }
    … …  
    154154    /*** fix the corresponding average entry ***/
    155155    n = ave_miss[i];
    156     if (catalog[0].average[n].Nn == 0) { /* this should never happen */
     156    if (catalog[0].average[n].Nmissing == 0) { /* this should never happen */
    157157      fprintf (stderr, "error? we deleted one too many missing?\n");
    158158      exit (1);
    159159    }
    160     catalog[0].average[n].Nn --;
     160    catalog[0].average[n].Nmissing --;
    161161    /* this was first entry in list */
    162     if ((catalog[0].average[n].missing == i) && (catalog[0].average[n].Nn > 0)) {
    163       m = catalog[0].average[n].missing;
     162    if ((catalog[0].average[n].missingOffset == i) && (catalog[0].average[n].Nmissing > 0)) {
     163      m = catalog[0].average[n].missingOffset;
    164164      for (j = 0; (j < Nmiss) && (next_miss[m+j] == -2); j++);
    165       catalog[0].average[n].missing = m + j;
     165      catalog[0].average[n].missingOffset = m + j;
    166166    }
    167167  }
    … …  
    172172  /* fix Average list: delete entries with Nm == 0 */
    173173  for (i = j = 0; (i < Nave) && (j < Nave); i++, j++) {
    174     for (; (j < Nave) && (catalog[0].average[j].Nm == 0); j++);
     174    for (; (j < Nave) && (catalog[0].average[j].Nmeasure == 0); j++);
    175175    if ((i != j) && (j < Nave)) {
    176176      catalog[0].average[i] = catalog[0].average[j];
    … …  
    189189  ALLOCATE (tmpmeasure, Measure, Nmeas);
    190190  for (i = 0; i < Nave; i++) {
    191     n = catalog[0].average[i].offset;
    192     catalog[0].average[i].offset = N;
    193     for (k = 0; k < catalog[0].average[i].Nm; k++, N++) {
     191    n = catalog[0].average[i].measureOffset;
     192    catalog[0].average[i].measureOffset = N;
     193    for (k = 0; k < catalog[0].average[i].Nmeasure; k++, N++) {
    194194      if ((n == -1) || (n == -2)) {
    195195        fprintf (stderr, "error: linked list is confused\n");
    … …  
    211211  ALLOCATE (tmpmissing, Missing, Nmiss);
    212212  for (i = 0; i < Nave; i++) {
    213     if (catalog[0].average[i].Nn > 0) {
    214       n = catalog[0].average[i].missing;
    215       catalog[0].average[i].missing = N;
    216       for (k = 0; k < catalog[0].average[i].Nn; k++, N++) {
     213    if (catalog[0].average[i].Nmissing > 0) {
     214      n = catalog[0].average[i].missingOffset;
     215      catalog[0].average[i].missingOffset = N;
     216      for (k = 0; k < catalog[0].average[i].Nmissing; k++, N++) {
    217217        if ((n == -1) || (n == -2)) {
    218218          fprintf (stderr, "error: linked list is confused\n");

  • branches/eam_branch_20080223/Ohana/src/gastro/src/getptolemy.c

    r15743 r16633  
    5050      stars[k].X = catalog.average[j].R;
    5151      stars[k].Y = catalog.average[j].D;
    52       stars[k].mag = catalog.measure[catalog.average[j].offset].M;
     52      stars[k].mag = catalog.measure[catalog.average[j].measureOffset].M;
    5353    }     
    5454    dvo_catalog_free (&catalog);

  • branches/eam_branch_20080223/Ohana/src/gastro2/src/getptolemy.c

    r15743 r16633  
    6161      Ref[0].stars[k].R = catalog.average[j].R;
    6262      Ref[0].stars[k].D = catalog.average[j].D;
    63       Ref[0].stars[k].M = catalog.measure[catalog.average[j].offset].M;
     63      Ref[0].stars[k].M = catalog.measure[catalog.average[j].measureOffset].M;
    6464    }     
    6565    dvo_catalog_free (&catalog);

  • branches/eam_branch_20080223/Ohana/src/getstar/src/select_by_region.c

    r15743 r16633  
    5454        mag = catalog[0].secfilt[i*Nsecfilt + Nsec].M;
    5555      } else {
    56         offset = catalog[0].average[i].offset;
    57         for (m = 0; m < catalog[0].average[i].Nm; m++) {
     56        offset = catalog[0].average[i].measureOffset;
     57        for (m = 0; m < catalog[0].average[i].Nmeasure; m++) {
    5858          if (catalog[0].measure[offset + m].photcode == code) {
    5959            mag = PhotRel (&catalog[0].measure[offset + m], &catalog[0].average[i], &catalog[0].secfilt[i*Nsecfilt]);
    … …  
    6666
    6767    output[0].average[Nave] = catalog[0].average[i];
    68     output[0].average[Nave].offset = Nmeas;
     68    output[0].average[Nave].measureOffset = Nmeas;
    6969    for (j = 0; j < Nsecfilt; j++) {
    7070      output[0].secfilt[Nsecfilt*Nave + j] = catalog[0].secfilt[Nsecfilt*i + j];
    … …  
    7272
    7373    Nm = 0;
    74     offset = catalog[0].average[i].offset;
     74    offset = catalog[0].average[i].measureOffset;
    7575
    76     for (j = 0; j < catalog[0].average[i].Nm; j++) {
     76    for (j = 0; j < catalog[0].average[i].Nmeasure; j++) {
    7777      output[0].measure[Nmeas] = catalog[0].measure[offset + j];
    7878      output[0].measure[Nmeas].averef = Nave;

  • branches/eam_branch_20080223/Ohana/src/getstar/src/write_getstar_ps1_dev_0.c

    r15543 r16633  
    5858    } else {
    5959      output[i].mag = NAN;
    60       offset = average[i].offset;
    61       for (m = 0; m < average[i].Nm; m++) {
     60      offset = average[i].measureOffset;
     61      for (m = 0; m < average[i].Nmeasure; m++) {
    6262        if (measure[offset + m].photcode == code_c0) {
    6363          output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
    … …  
    7272    } else {
    7373      output[i].c1 = NAN;
    74       offset = average[i].offset;
    75       for (m = 0; m < average[i].Nm; m++) {
     74      offset = average[i].measureOffset;
     75      for (m = 0; m < average[i].Nmeasure; m++) {
    7676        if (measure[offset + m].photcode == code_c1) {
    7777          output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
    … …  
    8686    } else {
    8787      output[i].c2 = NAN;
    88       offset = average[i].offset;
    89       for (m = 0; m < average[i].Nm; m++) {
     88      offset = average[i].measureOffset;
     89      for (m = 0; m < average[i].Nmeasure; m++) {
    9090        if (measure[offset + m].photcode == code_c2) {
    9191          output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);

  • branches/eam_branch_20080223/Ohana/src/getstar/src/write_getstar_ps1_dev_1.c

    r15543 r16633  
    6161    } else {
    6262      output[i].mag = NAN;
    63       offset = average[i].offset;
    64       for (m = 0; m < average[i].Nm; m++) {
     63      offset = average[i].measureOffset;
     64      for (m = 0; m < average[i].Nmeasure; m++) {
    6565        if (measure[offset + m].photcode == code_c0) {
    6666          output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
    … …  
    7575    } else {
    7676      output[i].c1 = NAN;
    77       offset = average[i].offset;
    78       for (m = 0; m < average[i].Nm; m++) {
     77      offset = average[i].measureOffset;
     78      for (m = 0; m < average[i].Nmeasure; m++) {
    7979        if (measure[offset + m].photcode == code_c1) {
    8080          output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
    … …  
    8989    } else {
    9090      output[i].c2 = NAN;
    91       offset = average[i].offset;
    92       for (m = 0; m < average[i].Nm; m++) {
     91      offset = average[i].measureOffset;
     92      for (m = 0; m < average[i].Nmeasure; m++) {
    9393        if (measure[offset + m].photcode == code_c2) {
    9494          output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);

  • branches/eam_branch_20080223/Ohana/src/getstar/src/write_getstar_ps1_dev_2.c

    r15543 r16633  
    6767    } else {
    6868      output[i].mag = NAN;
    69       offset = average[i].offset;
    70       for (m = 0; m < average[i].Nm; m++) {
     69      offset = average[i].measureOffset;
     70      for (m = 0; m < average[i].Nmeasure; m++) {
    7171        if (measure[offset + m].photcode == code_c0) {
    7272          output[i].mag = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
    … …  
    8181    } else {
    8282      output[i].c1 = NAN;
    83       offset = average[i].offset;
    84       for (m = 0; m < average[i].Nm; m++) {
     83      offset = average[i].measureOffset;
     84      for (m = 0; m < average[i].Nmeasure; m++) {
    8585        if (measure[offset + m].photcode == code_c1) {
    8686          output[i].c1 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);
    … …  
    9595    } else {
    9696      output[i].c2 = NAN;
    97       offset = average[i].offset;
    98       for (m = 0; m < average[i].Nm; m++) {
     97      offset = average[i].measureOffset;
     98      for (m = 0; m < average[i].Nmeasure; m++) {
    9999        if (measure[offset + m].photcode == code_c2) {
    100100          output[i].c2 = PhotRel (&measure[offset + m], &average[i], &secfilt[i*Nsecfilt]);

  • branches/eam_branch_20080223/Ohana/src/libautocode/def/average.d

    r15511 r16633  
    22EXTNAME      DVO_AVERAGE
    33TYPE         BINTABLE
    4 SIZE         72
     4SIZE         80
    55DESCRIPTION  DVO Average Object Table
    66
    … …  
    1919FIELD dP,             PAR_ERR,    float,            parallax error,               arcsec
    2020
    21 FIELD Xp,             SIGMA_POS,  short,            position scatter,             1/100 arcsec
    22 FIELD Nm,             NMEAS,      unsigned short,   number of measures
    23 FIELD Nn,             NMISS,      unsigned short,   number of missings
     21FIELD Xp,             SIGMA_POS,   short,           position scatter,             1/100 arcsec
     22FIELD Nmeasure,       NMEASURE,    unsigned short,  number of psf measurements
     23FIELD Nmissing,       NMISSING,    unsigned short,  number of missings
     24FIELD Nextend,        NEXTEND,     unsigned short,  number of extended measurements
     25FIELD measureOffset,  OFF_MEASURE, int,             offset to first psf measurement
     26FIELD missingOffset,  OFF_MISSING, int,             offset to first missing obs
     27FIELD extendOffset,   OFF_EXTEND,  int,             offset to first extended measurement
     28
    2429FIELD code,           code,       unsigned short,   ID code (star; ghost; etc)
    25 FIELD offset,         offset,     int,              offset to first measurement
    26 FIELD missing,        missing,    int,              offset to first missing obs
     30FIELD dummy,          DUMMY,      char[2],          padding
    2731
    2832# Pan-STARRS uses a 64-bit detection ID.  keep this in two 32 bit ints for backwards compatibility?

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_catalog_chipcoords.c

    r12332 r16633  
    5454 
    5555  for (i = 0; i < catalog[0].Naverage; i++) {
    56     m = average[i].offset;
    57     for (j = 0; j < average[i].Nm; j++, m++) {
     56    m = average[i].measureOffset;
     57    for (j = 0; j < average[i].Nmeasure; j++, m++) {
    5858      ra  = average[i].R - measure[m].dR / 3600.0;
    5959      dec = average[i].D - measure[m].dD / 3600.0;

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_catalog_raw.c

    r15743 r16633  
    188188  if (catalog[0].catflags & LOAD_AVES) {
    189189    for (i = Nmeas = Nmiss = 0; i < catalog[0].Naverage; i++) {
    190       Nmeas += catalog[0].average[i].Nm;
    191       Nmiss += catalog[0].average[i].Nn;
     190      Nmeas += catalog[0].average[i].Nmeasure;
     191      Nmiss += catalog[0].average[i].Nmissing;
    192192    }
    193193    if ((Nmeas != catalog[0].Nmeasure) || (Nmiss != catalog[0].Nmissing)) {

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_convert_PS1_DEV_1.c

    r15038 r16633  
    101101
    102102  for (i = 0; i < Nvalues; i++) {
     103    out[i].R             = in[i].R;     
     104    out[i].D             = in[i].D;     
     105    out[i].Xp            = in[i].Xp;     
     106    out[i].Nmeasure      = in[i].Nm;     
     107    out[i].Nmissing      = in[i].Nn;     
     108    out[i].code          = in[i].code;   
     109    out[i].measureOffset = in[i].offset;
     110    out[i].missingOffset = in[i].missing;
     111    out[i].dR            = in[i].dR;
     112    out[i].dD            = in[i].dD;
     113    out[i].uR            = in[i].uR;
     114    out[i].uD            = in[i].uD;
     115    out[i].duR           = in[i].duR;
     116    out[i].duD           = in[i].duD;
     117    out[i].P             = in[i].P;
     118    out[i].dP            = in[i].dP;
     119    out[i].objID_hi      = in[i].objID_hi;
     120    out[i].objID_lo      = in[i].objID_lo;
     121  }
     122  return (out);
     123}
     124
     125/* convert internal averages to panstarrs-format averages */
     126// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
     127Average_PS1_DEV_1 *AverageInternalTo_PS1_DEV_1 (Average *in, int Nvalues, SecFilt *primary) {
     128
     129  int i;
     130  Average_PS1_DEV_1 *out;
     131
     132  ALLOCATE (out, Average_PS1_DEV_1, Nvalues);
     133
     134  for (i = 0; i < Nvalues; i++) {
    103135    out[i].R        = in[i].R;     
    104136    out[i].D        = in[i].D;     
    105137    out[i].Xp       = in[i].Xp;     
    106     out[i].Nm       = in[i].Nm;     
    107     out[i].Nn       = in[i].Nn;     
     138    out[i].Nm       = in[i].Nmeasure;     
     139    out[i].Nn       = in[i].Nmissing;     
    108140    out[i].code     = in[i].code;   
    109     out[i].offset   = in[i].offset;
    110     out[i].missing  = in[i].missing;
    111     out[i].dR       = in[i].dR;
    112     out[i].dD       = in[i].dD;
    113     out[i].uR       = in[i].uR;
    114     out[i].uD       = in[i].uD;
    115     out[i].duR      = in[i].duR;
    116     out[i].duD      = in[i].duD;
    117     out[i].P        = in[i].P;
    118     out[i].dP       = in[i].dP;
    119     out[i].objID_hi = in[i].objID_hi;
    120     out[i].objID_lo = in[i].objID_lo;
    121   }
    122   return (out);
    123 }
    124 
    125 /* convert internal averages to panstarrs-format averages */
    126 // 'primary is needed to conform with the API for Loneos and Elixir, but is not used
    127 Average_PS1_DEV_1 *AverageInternalTo_PS1_DEV_1 (Average *in, int Nvalues, SecFilt *primary) {
    128 
    129   int i;
    130   Average_PS1_DEV_1 *out;
    131 
    132   ALLOCATE (out, Average_PS1_DEV_1, Nvalues);
    133 
    134   for (i = 0; i < Nvalues; i++) {
    135     out[i].R        = in[i].R;     
    136     out[i].D        = in[i].D;     
    137     out[i].Xp       = in[i].Xp;     
    138     out[i].Nm       = in[i].Nm;     
    139     out[i].Nn       = in[i].Nn;     
    140     out[i].code     = in[i].code;   
    141     out[i].offset   = in[i].offset;
    142     out[i].missing  = in[i].missing;
     141    out[i].offset   = in[i].measureOffset;
     142    out[i].missing  = in[i].missingOffset;
    143143    out[i].dR       = in[i].dR;
    144144    out[i].dD       = in[i].dD;

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_convert_elixir.c

    r15511 r16633  
    9595
    9696  for (i = 0; i < Nvalues; i++) {
    97     out[i].R       = in[i].R;     
    98     out[i].D       = in[i].D;     
    99     out[i].Xp      = in[i].Xp;     
    100     out[i].Nm      = in[i].Nm;     
    101     out[i].Nn      = in[i].Nn;     
    102     out[i].code    = in[i].code;   
    103     out[i].offset = in[i].offset;
    104     out[i].missing = in[i].missing;
     97    out[i].R             = in[i].R;     
     98    out[i].D             = in[i].D;     
     99    out[i].Xp            = in[i].Xp;     
     100    out[i].Nmeasure      = in[i].Nm;     
     101    out[i].Nmissing      = in[i].Nn;     
     102    out[i].code          = in[i].code;   
     103    out[i].measureOffset = in[i].offset;
     104    out[i].missingOffset = in[i].missing;
    105105
    106106    /* these don't exist in Elixir */
    … …  
    139139    out[i].D       = in[i].D;     
    140140    out[i].Xp      = in[i].Xp;     
    141     out[i].Nm      = in[i].Nm;     
    142     out[i].Nn      = in[i].Nn;     
     141    out[i].Nm      = in[i].Nmeasure;     
     142    out[i].Nn      = in[i].Nmissing;     
    143143    out[i].code    = in[i].code;   
    144     out[i].offset  = in[i].offset;
    145     out[i].missing = in[i].missing;
     144    out[i].offset  = in[i].measureOffset;
     145    out[i].missing = in[i].missingOffset;
    146146
    147147    out[i].M       = isnan(primary[i].M)  ? NAN_S_SHORT : primary[i].M   * 1000.0;

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_convert_loneos.c

    r15511 r16633  
    8787
    8888  for (i = 0; i < Nvalues; i++) {
    89     out[i].R       = in[i].R;     
    90     out[i].D       = in[i].D;     
    91     out[i].Xp      = in[i].Xp;     
    92     out[i].Nm      = in[i].Nm;     
    93     out[i].Nn      = in[i].Nn;     
    94     out[i].code    = in[i].code;   
    95     out[i].offset = in[i].offset;
    96     out[i].missing = in[i].missing;
     89    out[i].R             = in[i].R;     
     90    out[i].D             = in[i].D;     
     91    out[i].Xp            = in[i].Xp;     
     92    out[i].Nmeasure      = in[i].Nm;     
     93    out[i].Nmissing      = in[i].Nn;     
     94    out[i].code          = in[i].code;   
     95    out[i].measureOffset = in[i].offset;
     96    out[i].missingOffset = in[i].missing;
    9797
    9898    /* these don't exist in Loneos */
    … …  
    131131    out[i].D       = in[i].D;     
    132132    out[i].Xp      = in[i].Xp;     
    133     out[i].Nm      = in[i].Nm;     
    134     out[i].Nn      = in[i].Nn;     
     133    out[i].Nm      = in[i].Nmeasure;     
     134    out[i].Nn      = in[i].Nmissing;     
    135135    out[i].code    = in[i].code;   
    136     out[i].offset  = in[i].offset;
    137     out[i].missing = in[i].missing;
     136    out[i].offset  = in[i].measureOffset;
     137    out[i].missing = in[i].missingOffset;
    138138
    139139    out[i].M       = isnan(primary[i].M)  ? NAN_S_SHORT : primary[i].M   * 1000.0;

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_0.c

    r15511 r16633  
    9999
    100100  for (i = 0; i < Nvalues; i++) {
     101    out[i].R             = in[i].R;     
     102    out[i].D             = in[i].D;     
     103    out[i].Xp            = in[i].Xp;     
     104    out[i].Nmeasure      = in[i].Nm;     
     105    out[i].Nmissing      = in[i].Nn;     
     106    out[i].code          = in[i].code;   
     107    out[i].measureOffset = in[i].offset;
     108    out[i].missingOffset = in[i].missing;
     109    out[i].dR            = in[i].dR;
     110    out[i].dD            = in[i].dD;
     111    out[i].uR            = in[i].uR;
     112    out[i].uD            = in[i].uD;
     113    out[i].duR           = in[i].duR;
     114    out[i].duD           = in[i].duD;
     115    out[i].P             = in[i].P;
     116    out[i].dP            = in[i].dP;
     117    out[i].objID_hi      = in[i].objID_hi;
     118    out[i].objID_lo      = in[i].objID_lo;
     119  }
     120  return (out);
     121}
     122
     123/* convert internal averages to panstarrs-format averages */
     124// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
     125Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, int Nvalues, SecFilt *primary) {
     126
     127  int i;
     128  Average_Panstarrs_DEV_0 *out;
     129
     130  ALLOCATE (out, Average_Panstarrs_DEV_0, Nvalues);
     131
     132  for (i = 0; i < Nvalues; i++) {
    101133    out[i].R        = in[i].R;     
    102134    out[i].D        = in[i].D;     
    103135    out[i].Xp       = in[i].Xp;     
    104     out[i].Nm       = in[i].Nm;     
    105     out[i].Nn       = in[i].Nn;     
     136    out[i].Nm       = in[i].Nmeasure;     
     137    out[i].Nn       = in[i].Nmissing;     
    106138    out[i].code     = in[i].code;   
    107     out[i].offset   = in[i].offset;
    108     out[i].missing  = in[i].missing;
    109     out[i].dR       = in[i].dR;
    110     out[i].dD       = in[i].dD;
    111     out[i].uR       = in[i].uR;
    112     out[i].uD       = in[i].uD;
    113     out[i].duR      = in[i].duR;
    114     out[i].duD      = in[i].duD;
    115     out[i].P        = in[i].P;
    116     out[i].dP       = in[i].dP;
    117     out[i].objID_hi = in[i].objID_hi;
    118     out[i].objID_lo = in[i].objID_lo;
    119   }
    120   return (out);
    121 }
    122 
    123 /* convert internal averages to panstarrs-format averages */
    124 // 'primary is needed to conform with the API for Loneos and Elixir, but is not used
    125 Average_Panstarrs_DEV_0 *AverageInternalTo_Panstarrs_DEV_0 (Average *in, int Nvalues, SecFilt *primary) {
    126 
    127   int i;
    128   Average_Panstarrs_DEV_0 *out;
    129 
    130   ALLOCATE (out, Average_Panstarrs_DEV_0, Nvalues);
    131 
    132   for (i = 0; i < Nvalues; i++) {
    133     out[i].R        = in[i].R;     
    134     out[i].D        = in[i].D;     
    135     out[i].Xp       = in[i].Xp;     
    136     out[i].Nm       = in[i].Nm;     
    137     out[i].Nn       = in[i].Nn;     
    138     out[i].code     = in[i].code;   
    139     out[i].offset   = in[i].offset;
    140     out[i].missing  = in[i].missing;
     139    out[i].offset   = in[i].measureOffset;
     140    out[i].missing  = in[i].missingOffset;
    141141    out[i].dR       = in[i].dR;
    142142    out[i].dD       = in[i].dD;

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_convert_panstarrs_DEV_1.c

    r15511 r16633  
    9999
    100100  for (i = 0; i < Nvalues; i++) {
     101    out[i].R             = in[i].R;     
     102    out[i].D             = in[i].D;     
     103    out[i].Xp            = in[i].Xp;     
     104    out[i].Nmeasure      = in[i].Nm;     
     105    out[i].Nmissing      = in[i].Nn;     
     106    out[i].code          = in[i].code;   
     107    out[i].measureOffset = in[i].offset;
     108    out[i].missingOffset = in[i].missing;
     109    out[i].dR            = in[i].dR;
     110    out[i].dD            = in[i].dD;
     111    out[i].uR            = in[i].uR;
     112    out[i].uD            = in[i].uD;
     113    out[i].duR           = in[i].duR;
     114    out[i].duD           = in[i].duD;
     115    out[i].P             = in[i].P;
     116    out[i].dP            = in[i].dP;
     117    out[i].objID_hi      = in[i].objID_hi;
     118    out[i].objID_lo      = in[i].objID_lo;
     119  }
     120  return (out);
     121}
     122
     123/* convert internal averages to panstarrs-format averages */
     124// 'primary is needed to conform with the API for Loneos and Elixir, but is not used
     125Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, int Nvalues, SecFilt *primary) {
     126
     127  int i;
     128  Average_Panstarrs_DEV_1 *out;
     129
     130  ALLOCATE (out, Average_Panstarrs_DEV_1, Nvalues);
     131
     132  for (i = 0; i < Nvalues; i++) {
    101133    out[i].R        = in[i].R;     
    102134    out[i].D        = in[i].D;     
    103135    out[i].Xp       = in[i].Xp;     
    104     out[i].Nm       = in[i].Nm;     
    105     out[i].Nn       = in[i].Nn;     
     136    out[i].Nm       = in[i].Nmeasure;     
     137    out[i].Nn       = in[i].Nmissing;     
    106138    out[i].code     = in[i].code;   
    107     out[i].offset   = in[i].offset;
    108     out[i].missing  = in[i].missing;
    109     out[i].dR       = in[i].dR;
    110     out[i].dD       = in[i].dD;
    111     out[i].uR       = in[i].uR;
    112     out[i].uD       = in[i].uD;
    113     out[i].duR      = in[i].duR;
    114     out[i].duD      = in[i].duD;
    115     out[i].P        = in[i].P;
    116     out[i].dP       = in[i].dP;
    117     out[i].objID_hi = in[i].objID_hi;
    118     out[i].objID_lo = in[i].objID_lo;
    119   }
    120   return (out);
    121 }
    122 
    123 /* convert internal averages to panstarrs-format averages */
    124 // 'primary is needed to conform with the API for Loneos and Elixir, but is not used
    125 Average_Panstarrs_DEV_1 *AverageInternalTo_Panstarrs_DEV_1 (Average *in, int Nvalues, SecFilt *primary) {
    126 
    127   int i;
    128   Average_Panstarrs_DEV_1 *out;
    129 
    130   ALLOCATE (out, Average_Panstarrs_DEV_1, Nvalues);
    131 
    132   for (i = 0; i < Nvalues; i++) {
    133     out[i].R        = in[i].R;     
    134     out[i].D        = in[i].D;     
    135     out[i].Xp       = in[i].Xp;     
    136     out[i].Nm       = in[i].Nm;     
    137     out[i].Nn       = in[i].Nn;     
    138     out[i].code     = in[i].code;   
    139     out[i].offset   = in[i].offset;
    140     out[i].missing  = in[i].missing;
     139    out[i].offset   = in[i].measureOffset;
     140    out[i].missing  = in[i].missingOffset;
    141141    out[i].dR       = in[i].dR;
    142142    out[i].dD       = in[i].dD;

  • branches/eam_branch_20080223/Ohana/src/libdvo/src/dvo_photcode_ops.c

    r15514 r16633  
    370370  if (color == NULL) return (NAN);
    371371  if (color[0].type == PHOT_REF) {
    372     for (i = 0; (i < average[0].Nm) && (isnan(m1)); i++) {
     372    for (i = 0; (i < average[0].Nmeasure) && (isnan(m1)); i++) {
    373373      if (measure[i].photcode == color[0].code) {
    374374        m1 = measure[i].M;
    … …  
    384384  if (color == NULL) return (NAN);
    385385  if (color[0].type == PHOT_REF) {
    386     for (i = 0; (i < average[0].Nm) && (isnan(m2)); i++) {
     386    for (i = 0; (i < average[0].Nmeasure) && (isnan(m2)); i++) {
    387387      if (measure[i].photcode == color[0].code) {
    388388        m2 = measure[i].M;
    … …  
    466466  if (code == NULL) return (FALSE);
    467467  if (code[0].type == PHOT_REF) {
    468     for (i = 0; i < average[0].Nm; i++) {
     468    for (i = 0; i < average[0].Nmeasure; i++) {
    469469      if (measure[i].photcode == c1) {
    470470        M1 = measure[i].M;
    … …  
    482482  if (code == NULL) return (FALSE);
    483483  if (code[0].type == PHOT_REF) {
    484     for (i = 0; i < average[0].Nm; i++) {
     484    for (i = 0; i < average[0].Nmeasure; i++) {
    485485      if (measure[i].photcode == c2) {
    486486        M2 = measure[i].M;

  • branches/eam_branch_20080223/Ohana/src/mosastro/src/getptolemy.c

    r15743 r16633  
    5050      stars[k].R = catalog.average[j].R;
    5151      stars[k].D = catalog.average[j].D;
    52       stars[k].M = catalog.measure[catalog.average[j].offset].M;
     52      stars[k].M = catalog.measure[catalog.average[j].measureOffset].M;
    5353    }     
    5454    dvo_catalog_free (&catalog);

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/avextract.c

    r15716 r16633  
    100100
    101101    for (j = 0; (j < catalog.Naverage) && !interrupt; j++) {
    102       m = catalog.average[j].offset;
     102      m = catalog.average[j].measureOffset;
    103103      // extract the relevant values
    104104      // XXX for measure values, this could be optimized for one loop over measures...

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/ccd.c

    r15509 r16633  
    7272    for (i = 0; i < catalog.Naverage; i++) {
    7373      M1 = M2 = NULL;
    74       m = catalog.average[i].offset;
     74      m = catalog.average[i].measureOffset;
    7575
    7676      SetSelectionParam (0);

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/cmd.c

    r15509 r16633  
    7070    for (i = 0; i < catalog.Naverage; i++) {
    7171      M1 = M3 = NULL;
    72       m = catalog.average[i].offset;
     72      m = catalog.average[i].measureOffset;
    7373
    7474      SetSelectionParam (0);

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/dbExtractAverages.c

    r15509 r16633  
    4545
    4646    case AVE_NMEAS:
    47       value = average[0].Nm;
     47      value = average[0].Nmeasure;
    4848      break;
    4949    case AVE_NMISS:
    50       value = average[0].Nn;
     50      value = average[0].Nmissing;
    5151      break;
    5252    case AVE_Xp:
    … …  
    7272          // XXX need to code this correctly: this returns just the first matching value
    7373          value = NAN;
    74           for (i = 0; i < average[0].Nm; i++) {
     74          for (i = 0; i < average[0].Nmeasure; i++) {
    7575            if (field->photcode->code != measure[i].photcode) continue;
    7676            value = measure[i].M;

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/dbExtractMeasures.c

    r15509 r16633  
    111111      break;
    112112    case MEAS_NMEAS: /* OK */
    113       value = average[0].Nm;
     113      value = average[0].Nmeasure;
    114114      break;
    115115    case MEAS_NMISS: /* OK */
    116       value = average[0].Nn;
     116      value = average[0].Nmissing;
    117117      break;
    118118    case MEAS_OBJFLAGS: /* OK */

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/fitcolors.c

    r14401 r16633  
    216216
    217217          M1 = M2 = NULL;
    218           m = catalog[k].average[i].offset;
     218          m = catalog[k].average[i].measureOffset;
    219219
    220220          SetSelectionParam (0);

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/fitsed.c

    r16040 r16633  
    207207
    208208      // load the measurements for this source
    209       m = catalog.average[i].offset;
    210       for (j = 0; j < catalog.average[i].Nm; j++) {
     209      m = catalog.average[i].measureOffset;
     210      for (j = 0; j < catalog.average[i].Nmeasure; j++) {
    211211        idx = hashcode[catalog.measure[m+j].photcode];
    212212        if (idx == -1) continue;

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/gstar.c

    r16040 r16633  
    151151        gprint (GP_LOG, "%11.7f ", catalog.average[k].R);
    152152        gprint (GP_LOG, "%11.7f ", catalog.average[k].D);
    153         gprint (GP_LOG, "%3d   ",  catalog.average[k].Nm);
     153        gprint (GP_LOG, "%3d   ",  catalog.average[k].Nmeasure);
    154154        gprint (GP_LOG, "%4.1f ",  0.01*catalog.average[k].Xp);
    155155        gprint (GP_LOG, "%5d",     catalog.average[k].code);
    … …  
    188188
    189189      if (GetMeasures || SaveVectors) {
    190         m = catalog.average[k].offset;
    191         for (j = 0; j < catalog.average[k].Nm; j++, m++) {
     190        m = catalog.average[k].measureOffset;
     191        for (j = 0; j < catalog.average[k].Nmeasure; j++, m++) {
    192192
    193193          Mcat = PhotCat (&catalog.measure[m]);

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/lcurve.c

    r16040 r16633  
    122122    if (r < Radius2) {
    123123      /* found star, extract measurements */
    124       m = catalog.average[N1[i]].offset;
    125       for (j = 0; j < catalog.average[N1[i]].Nm; j++, m++) {
     124      m = catalog.average[N1[i]].measureOffset;
     125      for (j = 0; j < catalog.average[N1[i]].Nmeasure; j++, m++) {
    126126        if (ErrorBars) dYvec.elements[N] = catalog.measure[m].dM;
    127127        Xvec.elements[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/lightcurve.c

    r16040 r16633  
    105105      k = N1[i];
    106106      /* found star, extract measurements */
    107       m = catalog.average[k].offset;
    108       for (j = 0; j < catalog.average[k].Nm; j++, m++) {
     107      m = catalog.average[k].measureOffset;
     108      for (j = 0; j < catalog.average[k].Nmeasure; j++, m++) {
    109109
    110110        if (PhotCodeSelect) {

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/mextract.c

    r15716 r16633  
    120120
    121121    for (j = 0; (j < catalog.Naverage) && !interrupt; j++) {
    122       m = catalog.average[j].offset;
    123       for (k = 0; (k < catalog.average[j].Nm); k++, m++) {
     122      m = catalog.average[j].measureOffset;
     123      for (k = 0; (k < catalog.average[j].Nmeasure); k++, m++) {
    124124
    125125        // extract the relevant values for this measurement

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/photometry.c

    r15509 r16633  
    562562  *nlist = 0;
    563563  Nlist = 0;
    564   NLIST = MAX (1, average[0].Nm);
     564  NLIST = MAX (1, average[0].Nmeasure);
    565565  ALLOCATE (list, double, NLIST);
    566566
    … …  
    569569
    570570  /* look for measures */
    571   for (i = 0; i < average[0].Nm; i++) {
     571  for (i = 0; i < average[0].Nmeasure; i++) {
    572572    TESTCODE (code, measure[i]);  /* skip measurements not matching photcode */
    573573    TESTMEASURE (measure[i]);     /* exclusions based on measure.params  */
    … …  
    633633
    634634    case AVE_NMEAS:
    635       value = average[0].Nm;
     635      value = average[0].Nmeasure;
    636636      break;
    637637    case AVE_NMISS:
    638       value = average[0].Nn;
     638      value = average[0].Nmissing;
    639639      break;
    640640    case AVE_Xp:
    … …  
    658658        case MAG_CAL:
    659659          value = NAN;
    660           for (i = 0; i < average[0].Nm; i++) {
     660          for (i = 0; i < average[0].Nmeasure; i++) {
    661661              if (code[0].code != measure[i].photcode) continue;
    662662              value = measure[i].M;
    … …  
    679679    case AVE_NCODE:
    680680      value = 0;
    681       for (i = 0; i < average[0].Nm; i++) {
     681      for (i = 0; i < average[0].Nmeasure; i++) {
    682682        if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].photcode)) continue;
    683683        value ++;
    … …  
    686686    case AVE_NPHOT:
    687687      value = 0;
    688       for (i = 0; i < average[0].Nm; i++) {
     688      for (i = 0; i < average[0].Nmeasure; i++) {
    689689        if (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].photcode)) continue;
    690690        if (measure[i].dbFlags & (ID_MEAS_POOR | ID_MEAS_SKIP)) continue;
    … …  
    695695    case AVE_NCRIT:
    696696      value = 0;
    697       for (i = 0; i < average[0].Nm; i++) {
     697      for (i = 0; i < average[0].Nmeasure; i++) {
    698698        if ((code != NULL) && (code[0].code != GetPhotcodeEquivCodebyCode (measure[i].photcode))) continue;
    699699        if (ErrSelect && (measure[i].dM > ErrValue)) continue;
    … …  
    716716 
    717717  Nt = Nc = 0;
    718   for (k = 0; k < average[0].Nm; k++) {
     718  for (k = 0; k < average[0].Nmeasure; k++) {
    719719    if ((code != NULL) && (code[0].code != GetPhotcodeEquivCodebyCode (measure[k].photcode))) continue;
    720720    Nc ++;
    … …  
    732732 
    733733  Nt[0] = Nt[1] = Nt[2] = 0;
    734   for (k = 0; k < average[0].Nm; k++) {
     734  for (k = 0; k < average[0].Nmeasure; k++) {
    735735    if (code != GetPhotcodeEquivCodebyCode (measure[k].photcode)) continue;
    736736    N = GetMeasureTypeCode (&measure[k]);
    … …  
    793793  if ((code != NULL) && (code[0].type == PHOT_REF)) {
    794794    Nm = 0;
    795     for (i = 0; i < average[0].Nm; i++) {
     795    for (i = 0; i < average[0].Nmeasure; i++) {
    796796      TESTCODE (code, measure[i]);
    797797      Nm++;
    … …  
    805805  if (FWHMSelect) {
    806806    Nm = 0;
    807     for (i = 0; i < average[0].Nm; i++) {
     807    for (i = 0; i < average[0].Nmeasure; i++) {
    808808      fwhm = measure[i].FWx / 100.0;
    809809      switch (FWHMsign) {
    … …  
    820820      Nm++;
    821821    }
    822     if (average[0].Nm * FWHMfrac > Nm) return (FALSE);
     822    if (average[0].Nmeasure * FWHMfrac > Nm) return (FALSE);
    823823  }
    824824
    … …  
    833833  if (NcodeSelect) {
    834834    Nm = 0;
    835     for (i = 0; i < average[0].Nm; i++) {
     835    for (i = 0; i < average[0].Nmeasure; i++) {
    836836      TESTCODE (code, measure[i]);
    837837      Nm++;
    … …  
    872872  if (NphotSelect) {
    873873    Nm = 0;
    874     for (i = 0; i < average[0].Nm; i++) {
     874    for (i = 0; i < average[0].Nmeasure; i++) {
    875875      TESTCODE (code, measure[i]);
    876876      if (measure[i].dbFlags && ID_MEAS_SKIP) continue;
    … …  
    931931   Ns    - secfilt entry (-1 for PRI)
    932932   &catalog.average[i],
    933    &catalog.measure[catalog.average[i].offset],
     933   &catalog.measure[catalog.average[i].measureOffset],
    934934   &catalog.secfilt[i*Nsec]
    935935*/
    … …  
    974974  *nlist = 0;
    975975  Nlist = 0;
    976   NLIST = MAX (1, average[0].Nm*average[0].Nm);
     976  NLIST = MAX (1, average[0].Nmeasure*average[0].Nmeasure);
    977977  ALLOCATE (list, double, NLIST);
    978978  M1 = M2 = NULL;
    … …  
    10151015  *nlist = 0;
    10161016  Nlist = 0;
    1017   NLIST = MAX (1, average[0].Nm*average[0].Nm);
     1017  NLIST = MAX (1, average[0].Nmeasure*average[0].Nmeasure);
    10181018  ALLOCATE (list, double, NLIST);
    10191019
    … …  
    10311031
    10321032  /* loop twice over all measures */
    1033   for (i = 0; i < average[0].Nm; i++) {
     1033  for (i = 0; i < average[0].Nmeasure; i++) {
    10341034    SetSelectionParam (Np0);
    10351035    TESTCODE (code[0], measure[i]);
    10361036    TESTMEASURE (measure[i]);
    10371037    SETMAG(M1, measure[i], mode[0]);
    1038     for (j = 0; j < average[0].Nm; j++) {
     1038    for (j = 0; j < average[0].Nmeasure; j++) {
    10391039      if (i == j) continue;
    10401040      SetSelectionParam (Np1);
    … …  
    10861086  *nlist = 0;
    10871087  Nlist = 0;
    1088   NLIST = MAX (1, average[0].Nm*average[0].Nm);
     1088  NLIST = MAX (1, average[0].Nmeasure*average[0].Nmeasure);
    10891089  ALLOCATE (list, double, NLIST);
    10901090
    … …  
    10991099
    11001100  /* loop twice over all measures */
    1101   for (i = 0; i < average[0].Nm; i++) {
     1101  for (i = 0; i < average[0].Nmeasure; i++) {
    11021102    TESTCODE (code[0], measure[i]);
    11031103    TESTMEASURE (measure[i]);
    11041104    SETMAG(M1, measure[i], mode[0]);
    1105     for (j = 0; j < average[0].Nm; j++) {
     1105    for (j = 0; j < average[0].Nmeasure; j++) {
    11061106      if (i == j) continue;
    11071107      TESTCODE (code[1], measure[j]);

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/pmeasure.c

    r15038 r16633  
    111111      while (catalog.average[i].R < Rmin) catalog.average[i].R += 360.0;
    112112      while (catalog.average[i].R > Rmax) catalog.average[i].R -= 360.0;
    113       m = catalog.average[i].offset;
    114       for (k = 0; k < catalog.average[i].Nm; k++) {
     113      m = catalog.average[i].measureOffset;
     114      for (k = 0; k < catalog.average[i].Nmeasure; k++) {
    115115        if (FlagClip) {
    116116          flags = catalog.measure[m+k].dbFlags;

  • branches/eam_branch_20080223/Ohana/src/opihi/dvo/subpix.c

    r16040 r16633  
    130130
    131131  /* only print the entries for existing measurements of this star */
    132   measure = &catalog.measure[catalog.average[Nentry].offset];
    133   Nmeasure = catalog.average[Nentry].Nm;
     132  measure = &catalog.measure[catalog.average[Nentry].measureOffset];
     133  Nmeasure = catalog.average[Nentry].Nmeasure;
    134134  for (i = 0; i < Nsub; i++) {
    135135    I = index[i];

  • branches/eam_branch_20080223/Ohana/src/relastro/src/UpdateObjects.c

    r16060 r16633  
    1818  for (i = 0; i < Ncatalog; i++) {
    1919    for (j = 0; j < catalog[i].Naverage; j++) {
    20       Nmax = MAX (Nmax, catalog[i].average[j].Nm);
     20      Nmax = MAX (Nmax, catalog[i].average[j].Nmeasure);
    2121    }
    2222  }
    … …  
    8181
    8282      N = 0;
    83       m = catalog[i].average[j].offset;
     83      m = catalog[i].average[j].measureOffset;
    8484
    8585      Tmin = Tmax = (catalog[i].measure[m].t - To) / (86400*365.25);
    8686      mode = FIT_MODE;
    8787
    88       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     88      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    8989        if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue;
    9090       
    … …  
    193193
    194194      // the measure fields must be updated before the average fields
    195       m = catalog[i].average[j].offset;
    196       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     195      m = catalog[i].average[j].measureOffset;
     196      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    197197        if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue;
    198198        setMeanR (fit.Ro, &catalog[i].measure[m], &catalog[i].average[j], &catalog[i].secfilt[j*PhotNsec]);

  • branches/eam_branch_20080223/Ohana/src/relastro/src/bcatalog.c

    r15743 r16633  
    2222  /* exclude stars not in range or with too few measurements */
    2323  for (i = 0; i < catalog[0].Naverage; i++) {
    24     if (catalog[0].average[i].Nm < 2) continue;
     24    if (catalog[0].average[i].Nmeasure < 2) continue;
    2525
    2626    /* start with all stars good */
    2727    subcatalog[0].average[Naverage] = catalog[0].average[i];
    28     subcatalog[0].average[Naverage].offset = Nmeasure;
     28    subcatalog[0].average[Naverage].measureOffset = Nmeasure;
    2929    for (j = 0; j < PhotNsec; j++) {
    3030      subcatalog[0].secfilt[PhotNsec*Naverage+j] = catalog[0].secfilt[PhotNsec*i+j];
    … …  
    3838
    3939    Nm = 0;
    40     for (j = 0; j < catalog[0].average[i].Nm; j++) {
     40    for (j = 0; j < catalog[0].average[i].Nmeasure; j++) {
    4141
    42       offset = catalog[0].average[i].offset + j;
     42      offset = catalog[0].average[i].measureOffset + j;
    4343
    4444      /* select measurements by photcode, if specified */
    … …  
    9595      continue;
    9696    }
    97     subcatalog[0].average[Naverage].Nm = Nm;
     97    subcatalog[0].average[Naverage].Nmeasure = Nm;
    9898    Naverage ++;
    9999    if (Naverage == NAVERAGE) {

  • branches/eam_branch_20080223/Ohana/src/relastro/src/load_catalogs.c

    r15743 r16633  
    3939        for (j = 0; j < catalog[i].Naverage; j++) {
    4040          catalog[i].average[j].code = 0;
    41           m = catalog[i].average[j].offset;
    42           for (k = 0; k < catalog[i].average[j].Nm; k++) {
     41          m = catalog[i].average[j].measureOffset;
     42          for (k = 0; k < catalog[i].average[j].Nmeasure; k++) {
    4343            catalog[i].measure[m+k].dbFlags = 0;
    4444          }

  • branches/eam_branch_20080223/Ohana/src/relastro/src/plot_scatter.c

    r12332 r16633  
    1212  for (i = 0; i < Ncatalog; i++) {
    1313    for (j = 0; j < catalog[i].Naverage; j++) {
    14       Ntot += catalog[i].average[j].Nm;
     14      Ntot += catalog[i].average[j].Nmeasure;
    1515    }
    1616  }
    … …  
    2525      /* calculate the average value for a single star */
    2626      if (catalog[i].average[j].code & STAR_BAD) continue; 
    27       m = catalog[i].average[j].offset;
     27      m = catalog[i].average[j].measureOffset;
    2828
    29       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     29      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    3030        if (catalog[i].measure[m].flags & MEAS_BAD) continue;
    3131

  • branches/eam_branch_20080223/Ohana/src/relastro/src/setExclusions.c

    r15130 r16633  
    1111  for (i = 0; i < Ncatalog; i++) {
    1212    for (j = 0; j < catalog[i].Naverage; j++) {
    13       m = catalog[i].average[j].offset;
    14       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     13      m = catalog[i].average[j].measureOffset;
     14      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    1515
    1616        /* select measurements by photcode */

  • branches/eam_branch_20080223/Ohana/src/relphot/src/StarOps.c

    r15514 r16633  
    1212  for (i = 0; i < Ncatalog; i++) {
    1313    for (j = 0; j < catalog[i].Naverage; j++) {
    14       Nmax = MAX (Nmax, catalog[i].average[j].Nm);
     14      Nmax = MAX (Nmax, catalog[i].average[j].Nmeasure);
    1515    }
    1616  }
    … …  
    4343      /* calculate the average value for a single star */
    4444      if (catalog[i].average[j].code & STAR_BAD) continue; 
    45       m = catalog[i].average[j].offset;
     45      m = catalog[i].average[j].measureOffset;
    4646
    4747      N = 0;
    48       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     48      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    4949        if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue;
    5050        // XXX allow REF stars (no Image Entry) to be included in the calculation this
    … …  
    9494  for (i = 0; i < Ncatalog; i++) {
    9595    for (j = 0; j < catalog[i].Naverage; j++) {
    96       Nmax = MAX (Nmax, catalog[i].average[j].Nm);
     96      Nmax = MAX (Nmax, catalog[i].average[j].Nmeasure);
    9797    }
    9898  }
    … …  
    107107
    108108      N = 0;
    109       m = catalog[i].average[j].offset;
    110       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     109      m = catalog[i].average[j].measureOffset;
     110      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    111111        if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue;
    112112        // XXX allow REF stars (no Image Entry) to be included in the calculation this
    … …  
    158158    for (j = 0; j < catalog[i].Naverage; j++) {
    159159
    160       m = catalog[i].average[j].offset;
    161       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     160      m = catalog[i].average[j].measureOffset;
     161      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    162162        if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue;
    163163        Mcal  = getMcal  (m, i);
    … …  
    247247  for (i = 0; i < Ncatalog; i++) {
    248248    for (j = 0; j < catalog[i].Naverage; j++) {
    249       Nmax = MAX (Nmax, catalog[i].average[j].Nm);
     249      Nmax = MAX (Nmax, catalog[i].average[j].Nmeasure);
    250250    }
    251251  }
    … …  
    270270
    271271      /* accumulate list of valid measurements */
    272       m = catalog[i].average[j].offset;
     272      m = catalog[i].average[j].measureOffset;
    273273      N = 0;
    274       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     274      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    275275        /* if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue; */
    276276        Mcal  = getMcal  (m, i);
    … …  
    305305      image_bad = IMAGE_BAD;
    306306      IMAGE_BAD = ID_IMAGE_NOCAL;
    307       m = catalog[i].average[j].offset;
     307      m = catalog[i].average[j].measureOffset;
    308308      N = 0;
    309       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     309      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    310310        /* if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue; */
    311311        Mcal  = getMcal  (m, i);
    … …  
    362362      /* calculate the average value for a single star */
    363363      if (catalog[i].average[j].code & STAR_BAD) continue; 
    364       m = catalog[i].average[j].offset;
     364      m = catalog[i].average[j].measureOffset;
    365365
    366366      N = 0;
    367       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     367      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    368368        Mcal = getMcal  (m, i);
    369369        if (isnan(Mcal)) continue;

  • branches/eam_branch_20080223/Ohana/src/relphot/src/bcatalog.c

    r15743 r16633  
    2222  /* exclude stars not in range or with too few measurements */
    2323  for (i = 0; i < catalog[0].Naverage; i++) {
    24     // if (catalog[0].average[i].Nm < 2) continue;
     24    // if (catalog[0].average[i].Nmeasure < 2) continue;
    2525
    2626    /* start with all stars good */
    2727    subcatalog[0].average[Naverage] = catalog[0].average[i];
    28     subcatalog[0].average[Naverage].offset = Nmeasure;
     28    subcatalog[0].average[Naverage].measureOffset = Nmeasure;
    2929    for (j = 0; j < PhotNsec; j++) {
    3030      subcatalog[0].secfilt[PhotNsec*Naverage+j] = catalog[0].secfilt[PhotNsec*i+j];
    … …  
    3939
    4040    Nm = 0;
    41     for (j = 0; j < catalog[0].average[i].Nm; j++) {
     41    for (j = 0; j < catalog[0].average[i].Nmeasure; j++) {
    4242
    43       offset = catalog[0].average[i].offset + j;
     43      offset = catalog[0].average[i].measureOffset + j;
    4444
    4545      /* select measurements by photcode */
    … …  
    9696    }
    9797    # endif
    98     subcatalog[0].average[Naverage].Nm = Nm;
     98    subcatalog[0].average[Naverage].Nmeasure = Nm;
    9999    Naverage ++;
    100100    if (Naverage == NAVERAGE) {

  • branches/eam_branch_20080223/Ohana/src/relphot/src/plot_scatter.c

    r15509 r16633  
    1111  for (i = 0; i < Ncatalog; i++) {
    1212    for (j = 0; j < catalog[i].Naverage; j++) {
    13       Ntot += catalog[i].average[j].Nm;
     13      Ntot += catalog[i].average[j].Nmeasure;
    1414    }
    1515  }
    … …  
    2424      /* calculate the average value for a single star */
    2525      if (catalog[i].average[j].code & STAR_BAD) continue; 
    26       m = catalog[i].average[j].offset;
     26      m = catalog[i].average[j].measureOffset;
    2727
    28       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     28      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    2929        if (catalog[i].measure[m].dbFlags & MEAS_BAD) continue;
    3030        Mcal = getMcal  (m, i);

  • branches/eam_branch_20080223/Ohana/src/relphot/src/setExclusions.c

    r15038 r16633  
    1010  for (i = 0; i < Ncatalog; i++) {
    1111    for (j = 0; j < catalog[i].Naverage; j++) {
    12       m = catalog[i].average[j].offset;
    13       for (k = 0; k < catalog[i].average[j].Nm; k++, m++) {
     12      m = catalog[i].average[j].measureOffset;
     13      for (k = 0; k < catalog[i].average[j].Nmeasure; k++, m++) {
    1414
    1515        /* select measurements by photcode */

  • branches/eam_branch_20080223/Ohana/src/relphot/src/setMrelFinal.c

    r15509 r16633  
    1313      catalog[0].secfilt[PhotNsec*i+PhotSec].Xm = NAN_S_SHORT;
    1414
    15       m = catalog[0].average[i].offset;
    16       for (j = 0; j < catalog[0].average[i].Nm; j++, m++) {
     15      m = catalog[0].average[i].measureOffset;
     16      for (j = 0; j < catalog[0].average[i].Nmeasure; j++, m++) {
    1717       
    1818        /* select measurements by photcode */
    … …  
    5656    catalog[0].average[i].code &= ~ID_STAR_FEW;
    5757    catalog[0].average[i].code &= ~ID_STAR_POOR;
    58     m = catalog[0].average[i].offset;
    59     for (j = 0; j < catalog[0].average[i].Nm; j++, m++) {
     58    m = catalog[0].average[i].measureOffset;
     59    for (j = 0; j < catalog[0].average[i].Nmeasure; j++, m++) {
    6060      catalog[0].measure[m].dbFlags &= ~ID_MEAS_NOCAL;
    6161    }
    … …  
    8080  /* mark measures which should be ignored on second pass */
    8181  for (i = 0; i < catalog[0].Naverage; i++) {
    82     Ntot += catalog[0].average[i].Nm;
     82    Ntot += catalog[0].average[i].Nmeasure;
    8383    if (catalog[0].found[i]) continue;
    8484
    85     m = catalog[0].average[i].offset;
    86     for (k = 0; k < catalog[0].average[i].Nm; k++, m++) {
     85    m = catalog[0].average[i].measureOffset;
     86    for (k = 0; k < catalog[0].average[i].Nmeasure; k++, m++) {
    8787      Ntry++;
    8888

  • branches/eam_branch_20080223/Ohana/src/uniphot/src/update_catalog.c

    r15509 r16633  
    1717    }
    1818
    19     m = catalog[0].average[i].offset;
    20     for (j = 0; j < catalog[0].average[i].Nm; j++, m++) {
     19    m = catalog[0].average[i].measureOffset;
     20    for (j = 0; j < catalog[0].average[i].Nmeasure; j++, m++) {
    2121      code = GetPhotcodebyCode (catalog[0].measure[m].photcode);
    2222      if (code == NULL) continue;
Note: See TracChangeset for help on using the changeset viewer.