IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 37049


Ignore:
Timestamp:
Jul 17, 2014, 10:21:10 AM (12 years ago)
Author:
eugene
Message:

various changes due to mods to average.d and measure.d; new parsing concept for photocode-related fields

Location:
trunk/Ohana/src/opihi
Files:
24 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/Ohana/src/opihi/cmd.basic/Makefile

    r35237 r37049  
    5555$(SRC)/substr.$(ARCH).o     \
    5656$(SRC)/strhash.$(ARCH).o     \
     57$(SRC)/strmatch.$(ARCH).o     \
    5758$(SRC)/strpop.$(ARCH).o     \
    5859$(SRC)/strsub.$(ARCH).o     \

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

    r35237 r37049  
    4040int fprintf_opihi   PROTO((int, char **));
    4141int strlen_func     PROTO((int, char **));
     42int strmatch        PROTO((int, char **));
    4243int substr_func     PROTO((int, char **));
    4344int strpop          PROTO((int, char **));
    … …  
    9798  {1, "strpop",        strpop,             "pop a string"},
    9899  {1, "strsub",        strsub,             "replace instances of a key in a string"},
     100  {1, "strmatch",      strmatch,           "string length"},
    99101  {1, "wait",          wait_func,          "wait until return is typed"},
    100102  {1, "which",         which,              "show command *"}

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

    r36084 r37049  
    22# define D_NLINES 100
    33static char prompt[] = ">> ";
    4 
    5 static int set_list_varname (char *line, char *base, int N, int excelStyle);
    64
    75int list (int argc, char **argv) {
    … …  
    311309  return (TRUE);
    312310}
    313 
    314 static int set_list_varname (char *line, char *base, int N, int excelStyle) {
    315 
    316   int i;
    317    
    318   // A-Z correspond to 0 - 25
    319 
    320   if (excelStyle) {
    321     float f = log(26.0);
    322     float g = (N == 0) ? 0.0 : log(1.0*N);
    323     int Ndigit = (int) (g / f) + 1;
    324     if (Ndigit > 10) {
    325       sprintf (line, "%s:ZZZZZZZZZZ", base);
    326       return FALSE;
    327     }
    328     char name[12];
    329     memset (name, 0, 12);
    330     for (i = 0; i < Ndigit; i++) {
    331       float Npow = Ndigit - i - 1;
    332       float g = pow(26.0, Npow);
    333       int V = (int) (N / g);
    334       name[i] = (Npow == 0.0) ? 'A' + V : 'A' + V - 1;
    335       N -= V * g;
    336     }
    337     sprintf (line, "%s:%s", base, name);
    338   } else {
    339     sprintf (line, "%s:%d", base, N);
    340   }
    341   return TRUE;
    342 }

  • trunk/Ohana/src/opihi/cmd.data/Makefile

    r36679 r37049  
    9898$(SRC)/point.$(ARCH).o          \
    9999$(SRC)/ps.$(ARCH).o             \
     100$(SRC)/print_vectors.$(ARCH).o  \
    100101$(SRC)/queuedelete.$(ARCH).o    \
    101102$(SRC)/queuedrop.$(ARCH).o      \

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

    r36679 r37049  
    8787int point            PROTO((int, char **));
    8888int ps               PROTO((int, char **));
     89int print_vectors    PROTO((int, char **));
    8990int queuelist        PROTO((int, char **));
    9091int queueload        PROTO((int, char **));
    … …  
    250251  {1, "ppm",          jpeg,             "convert display graphic to PPM"},
    251252  {1, "ps",           ps,               "convert display to PostScript"},
     253  {1, "print_vectors", print_vectors,   "print a set of vectors"},
    252254  {1, "queuedelete",  queuedelete,      "delete a queue"},
    253255  {1, "queuedrop",    queuedrop,        "drop values from queue matching a key"},

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

    r36375 r37049  
    33FILE *f = (FILE *) NULL;
    44char filename[2048];
     5
     6void read_vectors_cleanup ();
    57
    68int datafile (int argc, char **argv) {
    … …  
    2325// vector types
    2426enum {COLTYPE_NONE, COLTYPE_FLT, COLTYPE_INT, COLTYPE_TIME, COLTYPE_CHAR};
    25 static int FITS_TRANSPOSE;
     27
     28static int      Nvec     = 0;
     29static Vector **vec      = NULL;
     30static char   **listname = NULL;
     31static int     *col      = NULL;
     32static int     *coltype  = NULL;
     33static char    *buffer   = NULL;
    2634
    2735int read_vectors (int argc, char **argv) {
    … …  
    2937  int TimeFormat;
    3038  time_t TimeReference;
    31   int i, j, Nskip, Narg, Nvec, *col, IsCSV, VERBOSE;
    32   int Nbytes, Nstart, NELEM, Nelem, nread, *coltype;
     39  int i, j, Nskip, Narg, IsCSV, VERBOSE;
     40  int Nbytes, Nstart, NELEM, Nelem, nread;
    3341  char *colstr, *c0, *c1, *extname;
    34   Vector **vec;
    35 
    36   char *buffer = NULL;
    37 
    38   FITS_TRANSPOSE = FALSE;
    39   if ((Narg = get_argument (argc, argv, "-transpose"))) {
    40     remove_argument (Narg, &argc, argv);
    41     FITS_TRANSPOSE = TRUE;
    42   }
     42  char varname[1024];  // used as a buffer for the names of string fields
    4343
    4444  /* auto-sense table type */
    … …  
    8888
    8989  Nvec = (argc - 1) / 2;
     90  ALLOCATE (listname, char *, Nvec);
    9091  ALLOCATE (vec, Vector *, Nvec);
    9192  ALLOCATE (col, int, Nvec);
    9293  ALLOCATE (coltype, int, Nvec);
     94  for (i = 0; i < Nvec; i++) {
     95    listname[i] = NULL;
     96    vec[i] = NULL;
     97  }
    9398
    9499  for (i = 0; i < Nvec; i++) {
    … …  
    115120    }
    116121
    117     if ((vec[i] = SelectVector (argv[2*i + 1], ANYVECTOR, TRUE)) == NULL) {
    118       gprint (GP_ERR, "USAGE: read name N name N ...\n");
    119       free (vec);
    120       free (col);
    121       return (FALSE);   
     122    if (coltype[i] == COLTYPE_CHAR) {
     123      listname[i] = strcreate (argv[2*i + 1]);
     124    } else {
     125      if ((vec[i] = SelectVector (argv[2*i + 1], ANYVECTOR, TRUE)) == NULL) {
     126        gprint (GP_ERR, "USAGE: read name N name N ...\n");
     127        read_vectors_cleanup();
     128        return (FALSE);   
     129      }
    122130    }
    123131
    … …  
    144152    bad_colname:
    145153      gprint (GP_ERR, "USAGE: read name N name N ...\n");
    146       free (vec);
    147       free (col);
     154      read_vectors_cleanup();
    148155      return (FALSE);   
    149156    }
    … …  
    153160  NELEM = 1000;
    154161  for (i = 0; i < Nvec; i++) {
    155     if ((coltype[i] == COLTYPE_INT) || (coltype[i] == COLTYPE_CHAR)) {
    156       ResetVector (vec[i], OPIHI_INT, NELEM);
    157     } else {
    158       // note that COLTYPE_TIME is a type of float
    159       ResetVector (vec[i], OPIHI_FLT, NELEM);
     162    switch (coltype[i]) {
     163      case COLTYPE_INT:
     164        ResetVector (vec[i], OPIHI_INT, NELEM);
     165        break;
     166      case COLTYPE_FLT:
     167      case COLTYPE_TIME:
     168        // note that COLTYPE_TIME is a type of float
     169        ResetVector (vec[i], OPIHI_FLT, NELEM);
     170        break;
     171      case COLTYPE_CHAR:
     172      default:
     173        break;
    160174    }
    161175  }
    … …  
    166180    if (scan_line_maxlen (f, buffer, 0x10000) == EOF) {
    167181      gprint (GP_ERR, "problem reading file %s\n", filename);
    168       free (vec);
    169       free (col);
     182      read_vectors_cleanup();
    170183      return FALSE;
    171184    }
    … …  
    213226      for (i = 0; i < Nvec; i++) {
    214227        int ivalue;
    215         char cvalue;
    216228        double dvalue;
    217229        time_t tvalue;
    … …  
    224236            break;
    225237          case COLTYPE_CHAR:
    226             readStatus = IsCSV ? charparse_csv (&cvalue, col[i], c0) : charparse (&cvalue, col[i], c0);
    227             vec[i][0].elements.Int[Nelem] = readStatus ? cvalue : 0;
    228             break;
     238            {
     239              // I need to get an isolated word in 'value' with the string value of this field
     240              char *ptr = IsCSV ? ptrparse_csv (col[i], c0) : ptrparse (col[i], c0);
     241              char *value = NULL;
     242              if (IsCSV) {
     243                char *end = parse_nextword_csv (ptr);
     244                if (end) {
     245                  value = end ? strncreate (ptr, end - ptr) : strcreate (ptr);
     246                }
     247              } else {
     248                value = thisword(ptr);
     249              }
     250              set_list_varname (varname, listname[i], Nelem, FALSE);
     251              set_str_variable (varname, value);
     252              free (value);
     253              break;
     254            }
    229255          case COLTYPE_FLT:
    230256            readStatus = IsCSV ? dparse_csv (&dvalue, col[i], c0) : dparse (&dvalue, col[i], c0);
    … …  
    256282        NELEM += 1000;
    257283        for (i = 0; i < Nvec; i++) {
    258           if (coltype[i] == COLTYPE_INT) {
    259             REALLOCATE (vec[i][0].elements.Int, opihi_int, NELEM);
    260           } else {
    261             REALLOCATE (vec[i][0].elements.Flt, opihi_flt, NELEM);
     284          switch (coltype[i]) {
     285            case COLTYPE_INT:
     286              ResetVector (vec[i], OPIHI_INT, NELEM);
     287              break;
     288            case COLTYPE_FLT:
     289            case COLTYPE_TIME:
     290              ResetVector (vec[i], OPIHI_FLT, NELEM);
     291              break;
     292            case COLTYPE_CHAR:
     293            default:
     294              break;
    262295          }
    263296        }
    … …  
    266299    }
    267300  }
     301  // set the final vector / list length
    268302  for (i = 0; i < Nvec; i++) {
    269     if (coltype[i] == COLTYPE_INT) {
    270       REALLOCATE (vec[i][0].elements.Int, opihi_int, MAX (Nelem,1));
    271     } else {
    272       REALLOCATE (vec[i][0].elements.Flt, opihi_flt, MAX (Nelem,1));
    273     }
    274     vec[i][0].Nelements = Nelem;
    275   }
    276  
    277   free (vec);
    278   free (col);
    279   if (buffer) free (buffer);
     303    switch (coltype[i]) {
     304      case COLTYPE_INT:
     305        ResetVector (vec[i], OPIHI_INT, Nelem);
     306        break;
     307      case COLTYPE_FLT:
     308      case COLTYPE_TIME:
     309        ResetVector (vec[i], OPIHI_FLT, Nelem);
     310        break;
     311      case COLTYPE_CHAR:
     312        sprintf (varname, "%s:n", listname[i]);
     313        set_int_variable (varname, Nelem);
     314        break;
     315      default:
     316        break;
     317    }
     318  }
     319  read_vectors_cleanup();
    280320  return (TRUE);
    281 
    282321}
    283322
    284 # define ESCAPE(MSG) { \
    285   gprint (GP_ERR, "%s\n", MSG); \
     323# define ESCAPE(...) {          \
     324  gprint (GP_ERR, __VA_ARGS__); \
    286325  if (CCDKeyword != NULL) free (CCDKeyword); \
    287326  gfits_free_table  (&table); \
    … …  
    292331
    293332  off_t Nbytes;
    294   int i, j, k, N, Nextend, Ny, Binary, vecType, padIfShort;
     333  int i, j, N, Nextend, Ny, Binary, vecType, padIfShort;
    295334  char type[16], ID[80], *CCDKeyword;
    296335  FTable table;
    297336  Header header;
    298337  Vector **vec;
     338  int FITS_TRANSPOSE;
    299339
    300340  table.buffer = NULL;
    301341  header.buffer = NULL;
     342
     343  FITS_TRANSPOSE = FALSE;
     344  if ((N = get_argument (argc, argv, "-transpose"))) {
     345    remove_argument (N, &argc, argv);
     346    FITS_TRANSPOSE = TRUE;
     347  }
    302348
    303349  CCDKeyword = NULL;
    … …  
    328374  // }
    329375
    330   if (argc < 2) ESCAPE ("USAGE: read -fits extension [-extnum] [-keyword key] name name ...");
    331 
    332   if (f == NULL) ESCAPE ("file not found");
     376  if (argc < 2) ESCAPE ("USAGE: read -fits extension [-extnum] [-keyword key] name name ...\n");
     377
     378  if (f == NULL) ESCAPE ("file not found\n");
    333379  fseeko (f, 0LL, SEEK_SET);
    334380  table.header = &header;
    … …  
    338384    // first extension is PHU, cannot be a table.
    339385    // Nextend counts from 0 for first extension
    340     if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file");
     386    if (!gfits_load_header (f, &header)) ESCAPE ("error reading primary header for file\n");
    341387    Nbytes = gfits_data_size (&header);
    342388    fseeko (f, Nbytes, SEEK_CUR);
    … …  
    344390
    345391    for (i = 0; i < Nextend; i++) {
    346       if (!gfits_load_header (f, &header)) ESCAPE ("extension not found");
     392      if (!gfits_load_header (f, &header)) ESCAPE ("extension %d not found\n", i);
    347393      Nbytes = gfits_data_size (&header);
    348394      /* skip the prior data buffers */
    … …  
    350396      gfits_free_header (&header);
    351397    }
    352     if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension");
    353     if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension");
     398    if (!gfits_load_header (f, &header)) ESCAPE ("error reading header for extension %d\n", Nextend);
     399    if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension %d\n", Nextend);
    354400
    355401  } else {
    … …  
    382428        continue;
    383429      }
    384       if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension");
     430      if (!gfits_fread_ftable_data (f, &table, padIfShort)) ESCAPE ("error reading table for extension\n");
    385431      break;
    386432    }
    … …  
    391437  gfits_scan (&header, "XTENSION", "%s", 1, type);
    392438  if (strcmp (type, "BINTABLE") && strcmp (type, "TABLE")) {
    393     ESCAPE ("specified extension is not a table\n");
     439    ESCAPE ("specified extension %s is not a table\n", type);
    394440  }
    395441  Binary = !strcmp (type, "BINTABLE");
    … …  
    418464       
    419465    if (!FITS_TRANSPOSE) {
     466      // read string column into a list rather than a vector
     467      if (!strcmp (type, "char")) {
     468        char *fieldName = argv[i];
     469        char *Ptr = data;
     470        char varname[1024];  // used as a buffer for the names of string fields
     471        for (j = 0; j < Ny; j++) {
     472          set_list_varname (varname, fieldName, j, FALSE);
     473          char *value = strncreate (&Ptr[j*Nval], Nval);
     474          // replace instances of $ with _
     475          char *p = strchr (value, '$');
     476          while (p) {
     477            *p = '_';
     478            p = strchr (p, '$');
     479          }
     480          set_str_variable (varname, value);
     481          free (value);
     482        }
     483        sprintf (varname, "%s:n", fieldName);
     484        set_int_variable (varname, Ny);
     485        continue;
     486      }
     487
    420488      // define the multifield vector names (Nval vectors x Ny elements)
    421489      ALLOCATE (vec, Vector *, Nval);
    … …  
    429497      }
    430498
    431       if (!strcmp (type, "char")) {
    432         char *Ptr = data;
    433         for (j = 0; j < Ny; j++) {
    434           for (k = 0; k < Nval; k++, Ptr++) {
    435             vec[k][0].elements.Int[j] = *Ptr;
    436           }
    437         }
    438       }
    439       if (!strcmp (type, "short")) {
    440         short *Ptr = data;
    441         for (j = 0; j < Ny; j++) {
    442           for (k = 0; k < Nval; k++, Ptr++) {
    443             vec[k][0].elements.Int[j] = *Ptr;
    444           }
    445         }
    446       }
    447       if (!strcmp (type, "int")) {
    448         int *Ptr = data;
    449         for (j = 0; j < Ny; j++) {
    450           for (k = 0; k < Nval; k++, Ptr++) {
    451             vec[k][0].elements.Int[j] = *Ptr;
    452           }
    453         }
    454       }
    455       if (!strcmp (type, "int64_t")) {
    456         int64_t *Ptr = data;
    457         for (j = 0; j < Ny; j++) {
    458           for (k = 0; k < Nval; k++, Ptr++) {
    459             vec[k][0].elements.Int[j] = *Ptr;
    460           }
    461         }
    462       }
    463       if (!strcmp (type, "float")) {
    464         float *Ptr = data;
    465         for (j = 0; j < Ny; j++) {
    466           for (k = 0; k < Nval; k++, Ptr++) {
    467             vec[k][0].elements.Flt[j] = *Ptr;
    468           }
    469         }
    470       }
    471       if (!strcmp (type, "double")) {
    472         double *Ptr = data;
    473         for (j = 0; j < Ny; j++) {
    474           for (k = 0; k < Nval; k++, Ptr++) {
    475             vec[k][0].elements.Flt[j] = *Ptr;
    476           }
    477         }
    478       }
     499      if (!VectorAssignData (vec, type, data, Ny, Nval)) ESCAPE ("bad column type %s", type);
     500
    479501    } else {
    480502      // define the multifield vector names (Ny vectors x Nval elements)
    … …  
    489511      }
    490512
    491       if (!strcmp (type, "char")) {
    492         char *Ptr = data;
    493         for (j = 0; j < Ny; j++) {
    494           for (k = 0; k < Nval; k++, Ptr++) {
    495             vec[j][0].elements.Int[k] = *Ptr;
    496           }
    497         }
    498       }
    499       if (!strcmp (type, "short")) {
    500         short *Ptr = data;
    501         for (j = 0; j < Ny; j++) {
    502           for (k = 0; k < Nval; k++, Ptr++) {
    503             vec[j][0].elements.Int[k] = *Ptr;
    504           }
    505         }
    506       }
    507       if (!strcmp (type, "int")) {
    508         int *Ptr = data;
    509         for (j = 0; j < Ny; j++) {
    510           for (k = 0; k < Nval; k++, Ptr++) {
    511             vec[j][0].elements.Int[k] = *Ptr;
    512           }
    513         }
    514       }
    515       if (!strcmp (type, "int64_t")) {
    516         int64_t *Ptr = data;
    517         for (j = 0; j < Ny; j++) {
    518           for (k = 0; k < Nval; k++, Ptr++) {
    519             vec[j][0].elements.Int[k] = *Ptr;
    520           }
    521         }
    522       }
    523       if (!strcmp (type, "float")) {
    524         float *Ptr = data;
    525         for (j = 0; j < Ny; j++) {
    526           for (k = 0; k < Nval; k++, Ptr++) {
    527             vec[j][0].elements.Flt[k] = *Ptr;
    528           }
    529         }
    530       }
    531       if (!strcmp (type, "double")) {
    532         double *Ptr = data;
    533         for (j = 0; j < Ny; j++) {
    534           for (k = 0; k < Nval; k++, Ptr++) {
    535             vec[j][0].elements.Flt[k] = *Ptr;
    536           }
    537         }
    538       }
     513      if (!VectorAssignDataTranspose (vec, type, data, Ny, Nval)) ESCAPE ("bad column type %s", type);
    539514    }
    540515    free (data);
    … …  
    546521  return (TRUE);
    547522}
     523
     524void read_vectors_cleanup () {
     525
     526  int i;
     527
     528  if (col) free (col);
     529  if (coltype) free (coltype);
     530  if (buffer) free (buffer);
     531  if (listname) {
     532    for (i = 0; i < Nvec; i++) {
     533      if (listname[i]) free (listname[i]);
     534    }
     535    free (listname);
     536  }
     537  if (vec) free (vec);
     538}

  • trunk/Ohana/src/opihi/dvo/Makefile

    r36833 r37049  
    2525$(SRC)/dvo_host_utils.$(ARCH).o         \
    2626$(SRC)/region_list.$(ARCH).o            \
    27 $(SRC)/find_matches.$(ARCH).o           \
    28 $(SRC)/photometry.$(ARCH).o             
     27$(SRC)/photcode_ops.$(ARCH).o           \
     28$(SRC)/find_matches.$(ARCH).o           
     29
     30# $(SRC)/photometry.$(ARCH).o             
     31
     32broken = \
     33$(SRC)/calextract.$(ARCH).o             \
     34$(SRC)/calmextract.$(ARCH).o            \
     35$(SRC)/ccd.$(ARCH).o                    \
     36$(SRC)/cmd.$(ARCH).o                    \
     37$(SRC)/dmagaves.$(ARCH).o               \
     38$(SRC)/dmagmeas.$(ARCH).o               \
     39$(SRC)/dmags.$(ARCH).o                  \
     40$(SRC)/ddmags.$(ARCH).o         \
     41$(SRC)/fitcolors.$(ARCH).o
    2942
    3043cmds = \
    … …  
    3245$(SRC)/avmatch.$(ARCH).o                \
    3346$(SRC)/badimages.$(ARCH).o              \
    34 $(SRC)/calextract.$(ARCH).o             \
    35 $(SRC)/calmextract.$(ARCH).o            \
    3647$(SRC)/catdir.$(ARCH).o                 \
    37 $(SRC)/ccd.$(ARCH).o                    \
    3848$(SRC)/cmatch.$(ARCH).o         \
    39 $(SRC)/cmd.$(ARCH).o                    \
    4049$(SRC)/cmpload.$(ARCH).o                \
    4150$(SRC)/cmpread.$(ARCH).o                \
    4251$(SRC)/coordimage.$(ARCH).o             \
    4352$(SRC)/coordmosaic.$(ARCH).o            \
    44 $(SRC)/ddmags.$(ARCH).o         \
    4553$(SRC)/detrend.$(ARCH).o                \
    46 $(SRC)/dmagaves.$(ARCH).o               \
    47 $(SRC)/dmagmeas.$(ARCH).o               \
    48 $(SRC)/dmags.$(ARCH).o                  \
    4954$(SRC)/dmt.$(ARCH).o                    \
    5055$(SRC)/elixir.$(ARCH).o                \
    51 $(SRC)/fitcolors.$(ARCH).o             \
    5256$(SRC)/fitsed.$(ARCH).o                \
    5357$(SRC)/gcat.$(ARCH).o                   \

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

    r35416 r37049  
    166166  needMeasures = FALSE;
    167167  for (i = 0; !needMeasures && (i < Nfields); i++) {
    168     if (fields[i].magMode == MAG_NONE) continue;
    169     if (fields[i].photcode == NULL) continue; // assert this?
     168    if (fields[i].photcode == NULL) continue; // non-measure fields do not have a photcode
    170169    if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE;
    171170    if (fields[i].photcode[0].type == PHOT_DEP) needMeasures = TRUE;

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

    r36084 r37049  
    152152  int needMeasures = FALSE;
    153153  for (i = 0; !needMeasures && (i < Nfields); i++) {
    154     if (fields[i].magMode == MAG_NONE) continue;
    155154    if (fields[i].photcode == NULL) continue; // assert this?
    156155    if (fields[i].photcode[0].type == PHOT_REF) needMeasures = TRUE;

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

    r34088 r37049  
    8383  /* interpret command-line options */
    8484  if ((selection = SetRegionSelection (&argc, argv)) == NULL) goto escape;
    85   if (!SetPhotSelections (&argc, argv, 4)) goto usage;
     85  // if (!SetPhotSelections (&argc, argv, 4)) goto usage;
    8686
    8787  PLOT = FALSE;

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

    r35109 r37049  
    1515  GSTAR_UCDIST,
    1616  GSTAR_AVE_AP_MAG,
    17   GSTAR_AVE_MAG_20,
    18   GSTAR_AVE_MAG_80,
     17  GSTAR_AVE_MAG_MIN,
     18  GSTAR_AVE_MAG_MAX,
    1919  GSTAR_AVE_KRON_MAG,
    2020  GSTAR_AVE_KRON_MAG_ERR,
    … …  
    307307          gprint (GP_LOG, "\n");
    308308
    309           /* M_20 */
    310           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_20);
    311           gprint (GP_LOG, "\n");
    312 
    313           /* M_80 */
    314           for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_80);;
     309          /* Mmin */
     310          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MIN);
     311          gprint (GP_LOG, "\n");
     312
     313          /* Mmax */
     314          for (j = 0; j < Nsecfilt; j++) printPhotcodeSequence (&catalog.average[k], &catalog.secfilt[Nsecfilt*k], j, GSTAR_AVE_MAG_MAX);;
    315315          gprint (GP_LOG, "\n");
    316316
    … …  
    374374          int Nv = index[j];
    375375
    376           Mcat = PhotCat (&catalog.measure[Nv]);
     376          Mcat = PhotCat (&catalog.measure[Nv], MAG_CLASS_PSF);
    377377          if (INST) {
    378             Mrel = PhotInst (&catalog.measure[Nv]);
     378            Mrel = PhotInst (&catalog.measure[Nv], MAG_CLASS_PSF);
    379379          } else {
    380             Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]);
     380            Mrel = PhotRel (&catalog.measure[Nv], &catalog.average[k], &catalog.secfilt[k*Nsecfilt], MAG_CLASS_PSF);
    381381          }
     382
     383          float dRoff = dvoOffsetR(&catalog.measure[Nv], &catalog.average[k]);
     384          float dDoff = dvoOffsetD(&catalog.measure[Nv], &catalog.average[k]);
    382385
    383386          if (GetMeasures && !QUIET) {
    … …  
    387390            gprint (GP_LOG, "%6.3f  ", catalog.measure[Nv].dM);
    388391            gprint (GP_LOG, "%20s  ",  date);
    389             gprint (GP_LOG, "%7.4f ",  catalog.measure[Nv].dR);
    390             gprint (GP_LOG, "%7.4f ",  catalog.measure[Nv].dD);
     392           
     393            gprint (GP_LOG, "%7.4f ",  dRoff);
     394            gprint (GP_LOG, "%7.4f ",  dDoff);
    391395            gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].photFlags);
    392396            gprint (GP_LOG, "0x%08x ", catalog.measure[Nv].dbFlags);
    … …  
    447451            vec3[0].elements.Flt[N] = catalog.measure[Nv].airmass;
    448452            vec4[0].elements.Flt[N] = catalog.measure[Nv].photcode;
    449             vec5[0].elements.Flt[N] = catalog.measure[Nv].dR;
    450             vec6[0].elements.Flt[N] = catalog.measure[Nv].dD;
     453            vec5[0].elements.Flt[N] = dRoff;
     454            vec6[0].elements.Flt[N] = dDoff;
    451455            N ++;
    452456            if (N == NPTS - 1) {
    … …  
    561565    case GSTAR_AVE_MAG_CHISQ: /* average mag chisq */
    562566      if (seq == -1) {
    563         print_short (NAN_S_SHORT, NAN_S_SHORT);
    564       } else {
    565         print_short (pow (10.0, 0.01*secfilt[seq].Xm), secfilt[seq].Xm);
     567        print_double (NAN);
     568      } else {
     569        print_double (secfilt[seq].Mchisq);
    566570      }
    567571      break;
    … …  
    596600      break;
    597601
    598     case GSTAR_AVE_MAG_20: /* average ap mags */
    599       if (seq == -1) {
    600         print_double (NAN);
    601       } else {
    602         print_short (0.001*secfilt[seq].M_20, secfilt[seq].M_20);
    603       }
    604       break;
    605 
    606     case GSTAR_AVE_MAG_80: /* average ap mags */
    607       if (seq == -1) {
    608         print_double (NAN);
    609       } else {
    610         print_short (0.001*secfilt[seq].M_80, secfilt[seq].M_80);
     602    case GSTAR_AVE_MAG_MIN: /* average ap mags */
     603      if (seq == -1) {
     604        print_double (NAN);
     605      } else {
     606        print_double (secfilt[seq].Mmin);
     607      }
     608      break;
     609
     610    case GSTAR_AVE_MAG_MAX: /* average ap mags */
     611      if (seq == -1) {
     612        print_double (NAN);
     613      } else {
     614        print_double (secfilt[seq].Mmax);
    611615      }
    612616      break;
    … …  
    632636        print_double (NAN);
    633637      } else {
    634         print_double_exp (secfilt[seq].FluxPSF);
     638        print_double_exp (secfilt[seq].FpsfStk);
    635639      }
    636640      break;
    … …  
    640644        print_double (NAN);
    641645      } else {
    642         print_double_exp (secfilt[seq].dFluxPSF);
     646        print_double_exp (secfilt[seq].dFpsfStk);
    643647      }
    644648      break;
    … …  
    648652        print_double (NAN);
    649653      } else {
    650         print_double_exp (secfilt[seq].FluxKron);
     654        print_double_exp (secfilt[seq].FkronStk);
    651655      }
    652656      break;
    … …  
    656660        print_double (NAN);
    657661      } else {
    658         print_double_exp (secfilt[seq].dFluxKron);
    659       }
    660       break;
    661 
    662   }
    663 }
     662        print_double_exp (secfilt[seq].dFkronStk);
     663      }
     664      break;
     665
     666  }
     667}

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

    r34088 r37049  
    33int imdata (int argc, char **argv) {
    44 
    5   off_t i, j, k, n, I;
     5  off_t i, j, k, I;
    66  int N, NPTS, found, mode, TimeSelect, TimeFormat;
    77  off_t Nregions, NREGIONS;
    … …  
    152152        for (i = 0; i < catalog.Nmeasure; i++) {
    153153          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    154           n = catalog.measure[i].averef;
    155           vec[0].elements.Flt[N] = catalog.average[n].R - catalog.measure[i].dR / 3600.0;
     154          vec[0].elements.Flt[N] = catalog.measure[i].R;
    156155          N++;
    157156          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    … …  
    161160        for (i = 0; i < catalog.Nmeasure; i++) {
    162161          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    163           n = catalog.measure[i].averef;
    164           vec[0].elements.Flt[N] = catalog.average[n].D - catalog.measure[i].dD / 3600.0;
     162          vec[0].elements.Flt[N] = catalog.measure[i].D;
    165163          N++;
    166164          CHECK_REALLOCATE (vec[0].elements.Flt, opihi_flt, NPTS, N, 1000);
    … …  
    194192        for (i = 0; i < catalog.Nmeasure; i++) {
    195193          if ((catalog.measure[i].t < start) || (catalog.measure[i].t > stop)) continue;
    196           n = catalog.measure[i].averef;
     194          //n = catalog.measure[i].averef;
    197195          // vec[0].elements.Flt[N] = catalog.average[n].M;
    198196          N++;

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

    r34088 r37049  
    185185    gprint (GP_ERR, "  Mcal : photometry calibration (mags)\n");
    186186    gprint (GP_ERR, "  dMcal : photometry calibration error (mags)\n");
    187     gprint (GP_ERR, "  Xm : chisq of photometry calibration\n");
     187    gprint (GP_ERR, "  Mchisq : chisq of photometry calibration\n");
    188188    gprint (GP_ERR, "  photcode : numeric photcode value for image\n");
    189189    gprint (GP_ERR, "  exptime : exposure duration (seconds)\n");

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

    r36833 r37049  
    6666  {1, "avmatch",     avmatch,      "extract average data values matched to RA,DEC points"},
    6767  {1, "badimages",   badimages,    "look for images with anomalous astrometry"},
    68   {1, "calextract",  calextract,   "extract photometry calibration"},
    69   {1, "calmextract", calmextract,  "extract photometry calibration"},
     68//  {1, "calextract",  calextract,   "extract photometry calibration"},
     69//  {1, "calmextract", calmextract,  "extract photometry calibration"},
    7070  {1, "catdir",      catdir_define,"re-define CATDIR"},
    71   {1, "ccd",         ccd,          "plot color-color diagram"},
     71//  {1, "ccd",         ccd,          "plot color-color diagram"},
    7272  {1, "cmatch",      cmatch,       "match two catalogs"},
    73   {1, "cmd",         cmd,          "plot cmd of stars in current region"},
     73//  {1, "cmd",         cmd,          "plot cmd of stars in current region"},
    7474  {1, "cmpload",     cmpload,      "load cmp file into ?"},
    7575  {1, "cmpread",     cmpread,      "read data from cmp format files"},
    … …  
    7777  {1, "coordmosaic", coordmosaic,  "generate a map of the distortion"},
    7878  {1, "psastro_model", psastro_model, "save psastro-format astrometry model"},
    79   {1, "ddmags",      ddmags,       "plot magnitude differences"},
     79//  {1, "ddmags",      ddmags,       "plot magnitude differences"},
    8080  {1, "detrend",     detrend,      "extract from detrend database?"},
    81   {1, "dmagaves",    dmagaves,     "foo"},
    82   {1, "dmagmeas",    dmagmeas,     "foo"},
    83   {1, "dmags",       dmags,        "plot differential magnitudes between filters"},
     81//  {1, "dmagaves",    dmagaves,     "foo"},
     82//  {1, "dmagmeas",    dmagmeas,     "foo"},
     83//  {1, "dmags",       dmags,        "plot differential magnitudes between filters"},
    8484  {1, "dmt",         dmt,          "plot mag scatter"},
    8585  {1, "elixir",      elixir,       "talk to elixir"},
    86   {1, "fitcolors",   fitcolors,    "fit chip-to-chip color terms"},
     86//  {1, "fitcolors",   fitcolors,    "fit chip-to-chip color terms"},
    8787  {1, "fitsed",      fitsed,       "fit stellar SEDs to objects"},
    8888  {1, "gcat",        gcat,         "get catalog at location"},

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

    r34584 r37049  
    129129        if (ErrorBars) dYvec.elements.Flt[N] = catalog.measure[m].dM;
    130130        Xvec.elements.Flt[N] = TimeValue (catalog.measure[m].t, TimeReference, TimeFormat);
    131         Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m]);
     131        Yvec.elements.Flt[N] = PhotCat (&catalog.measure[m], MAG_CLASS_PSF);
    132132        /**** need to use PhotRel optionally here ****/
    133133        N++;

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

    r27435 r37049  
    121121        dmvec[0].elements.Flt[N] = catalog.measure[m].dM;
    122122        if (RELPHOT) {
    123           mvec[0].elements.Flt[N] = PhotCat (&catalog.measure[m]);
     123          mvec[0].elements.Flt[N] = PhotCat (&catalog.measure[m], MAG_CLASS_PSF);
    124124        } else {
    125           mvec[0].elements.Flt[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt]);
     125          mvec[0].elements.Flt[N] = PhotRel (&catalog.measure[m], &catalog.average[k], &catalog.secfilt[k*Nsecfilt], MAG_CLASS_PSF);
    126126        }
    127127        N++;

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

    r36630 r37049  
    4141  }
    4242
     43# if (0)
    4344/* selection criteria */
    4445/* selections based on Measure quantities */
    … …  
    7879static time_t TimeReference;
    7980static int TimeFormat;
    80 
     81# endif
     82
     83# if (0)
    8184int GetTimeSelection (time_t *tz, time_t *te) {
    8285  *tz = tzero;
    … …  
    298301  return;
    299302}
    300 
    301 /* (re)load photcodes from photcode table */
    302 int InitPhotcodes () {
    303 
    304   double ZERO_POINT;
    305   char MasterPhotcodeFile[256];
    306   char CatdirPhotcodeFile[256];
    307   char *catdir;
    308 
    309   if (VarConfig ("ZERO_PT", "%lf", &ZERO_POINT) == (char *) NULL) {
    310     gprint (GP_ERR, "ZERO_PT undefined in config\n");
    311     return (FALSE);
    312   }
    313   SetZeroPoint (ZERO_POINT);
    314 
    315   catdir = GetCATDIR();
    316   if (catdir == NULL) {
    317     CatdirPhotcodeFile[0] = 0;
    318   } else {
    319     sprintf (CatdirPhotcodeFile, "%s/Photcodes.dat", catdir);
    320   }
    321 
    322   if (VarConfig ("PHOTCODE_FILE", "%s", MasterPhotcodeFile) == (char *) NULL) {
    323     gprint (GP_ERR, "PHOTCODE_FILE undefined in config\n");
    324     return (FALSE);
    325   }
    326 
    327   // XXX now that DVO does not allow write access, we can drop the MasterPhotcodeFile
    328   if (!LoadPhotcodes (CatdirPhotcodeFile, MasterPhotcodeFile, FALSE)) {
    329     gprint (GP_ERR, "error loading photcode table %s or master file %s\n", CatdirPhotcodeFile, MasterPhotcodeFile);
    330     return (FALSE);
    331   }
    332   return (TRUE);
    333 }
    334 
     303# endif
     304
     305# if (0)
    335306int ListPhotSelections () {
    336307
    … …  
    11211092  return (list);
    11221093}
    1123 
     1094# endif
     1095
     1096# if (0)
    11241097double GetMeasure (int param, Average *average, Measure *measure, double mag) {
    11251098
    … …  
    11351108      break;
    11361109    case MEAS_RA: /* OK */
    1137       value = average[0].R - measure[0].dR / 3600.0;
     1110      value = measure[0].R;
    11381111      break;
    11391112    case MEAS_DEC: /* OK */
    1140       value = average[0].D - measure[0].dD / 3600.0;
     1113      value = measure[0].D;
    11411114      break;
    11421115    case MEAS_DOPHOT: /* OK */
    … …  
    11561129      break;
    11571130    case MEAS_RA_OFFSET: /* OK */
    1158       value = measure[0].dR;
     1131      value = dvoOffsetR(measure, average);
    11591132      break;
    11601133    case MEAS_DEC_OFFSET: /* OK */
    1161       value = measure[0].dD;
     1134      value = dvoOffsetD(measure, average);
    11621135      break;
    11631136    case MEAS_FWHM: /* OK */
    … …  
    11721145      value = measure[0].Xccd;
    11731146# else
    1174       ra  = average[0].R - measure[0].dR / 3600.0;
    1175       dec = average[0].D - measure[0].dD / 3600.0;
     1147      ra  = measure[0].R;
     1148      dec = measure[0].D;
    11761149      image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
    11771150      if (image == NULL) break;
    … …  
    11851158      value = measure[0].Yccd;
    11861159# else
    1187       ra  = average[0].R - measure[0].dR / 3600.0;
    1188       dec = average[0].D - measure[0].dD / 3600.0;
     1160      ra  = measure[0].R;
     1161      dec = measure[0].D;
    11891162      image = MatchImageDVO (measure[0].t, measure[0].photcode, measure[0].imageID);
    11901163      if (image == NULL) break;
    … …  
    11951168# if 0
    11961169    case MEAS_XMOSAIC: /* OK */
    1197       ra  = average[0].R - measure[0].dR / 3600.0;
    1198       dec = average[0].D - measure[0].dD / 3600.0;
     1170      ra  = measure[0].R;
     1171      dec = measure[0].D;
    11991172      mosaic = MatchMosaic (measure[0].t, measure[0].photcode); // XXX not used anymore
    12001173      if (mosaic == NULL) break;
    … …  
    12031176      break;
    12041177    case MEAS_YMOSAIC: /* OK */
    1205       ra  = average[0].R - measure[0].dR / 3600.0;
    1206       dec = average[0].D - measure[0].dD / 3600.0;
     1178      ra  = measure[0].R;
     1179      dec = measure[0].D;
    12071180      mosaic = MatchMosaic (measure[0].t, measure[0].photcode); // XXX not used anymore
    12081181      if (mosaic == NULL) break;
    … …  
    12141187  return (value);
    12151188}
     1189# endif
    12161190
    12171191/** the mosaic entries do not use the registered mosaic found

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

    r34088 r37049  
    203203        if (TimeSelect && (catalog.measure[m+k].t > tzero + trange)) continue;
    204204        if ((PhotcodeClip != -1) && (catalog.measure[m+k].photcode != PhotcodeClip)) continue;
    205         mag = PhotCat (&catalog.measure[m+k]);
     205        mag = PhotCat (&catalog.measure[m+k], MAG_CLASS_PSF);
    206206        Zvec[Npts] = MIN (1.0, MAX (0.01, (mag - Mz) / Mr));
    207207        if (LimExclude && (Zvec[Npts] > 0.99)) continue;
    208208        if (Zvec[Npts] < 0.011) continue;
    209         R = catalog.average[i].R - catalog.measure[m+k].dR/3600.0;
    210         D = catalog.average[i].D - catalog.measure[m+k].dD/3600.0;
     209        R = catalog.measure[m+k].R;
     210        D = catalog.measure[m+k].D;
    211211        // XXX drop this check
    212212        if ((R < Rmin) || (R > Rmax) || (D < -90.0) || (D > 90.0)) {
    213213          char *date;
    214214          date = ohana_sec_to_date (catalog.measure[m+k].t);
    215           gprint (GP_LOG, "out: %f, %f : %s : (%f, %f) + (%f, %f)\n", R, D, date, catalog.average[i].R, catalog.average[i].D, catalog.measure[m+k].dR/3600.0, catalog.measure[m+k].dD/3600.0);
     215          gprint (GP_LOG, "out: %f, %f : %s : (%f, %f) + (%f, %f)\n", R, D, date, catalog.average[i].R, catalog.average[i].D, catalog.measure[m+k].R, catalog.measure[m+k].D);
    216216          free (date);
    217217        }

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

    r31635 r37049  
    138138    for (j = 0; j < Nmeasure; j++) {
    139139      if (measure[j].t == Timage) {
    140         Mabs = PhotCat (&measure[j]);
     140        Mabs = PhotCat (&measure[j], MAG_CLASS_PSF);
    141141        RD_to_XY (&X, &Y, Ra, Dec, &image[I].coords);
    142142        t = TimeValue (measure[j].t, TimeReference, TimeFormat);

  • trunk/Ohana/src/opihi/include/dvomath.h

    r36375 r37049  
    170170Vector      **ReadVectorTableFITS   PROTO((char *filename, char *extname, int *Nvec));
    171171
     172int           VectorAssignData          PROTO((Vector **vec, char *type, void *data, int Nrows, int Nval));
     173int           VectorAssignDataTranspose PROTO((Vector **vec, char *type, void *data, int Nrows, int Nval));
     174
    172175/* buffer handling */
    173176Buffer       *InitBuffer            PROTO((void));

  • trunk/Ohana/src/opihi/include/dvoshell.h

    r35416 r37049  
    9090int           wordhash              PROTO((char *word));
    9191
    92 int          GetMagMode             PROTO((char *string));
    93 PhotCode    *ParsePhotcodeField     PROTO((char *field, int *mode, int def));
    94 int          ParseMeasureField      PROTO((dbField *field, char *fieldName));
    95 int          ParseAverageField      PROTO((dbField *field, char *fieldName));
    96 int          ParseImageField        PROTO((dbField *field, char *fieldName));
    97 
    98 dbValue      dbExtractMeasures      PROTO((Average *average, SecFilt *secfilt, Measure *measure, dbField *field));
    99 dbValue      dbExtractImages        PROTO((Image *image, off_t Nimage, off_t N, dbField *field));
    100 
    10192int          HostTableLaunchJobs    PROTO((SkyList *sky, HostTable *table, char *basecmd, char *options, int VERBOSE));
    10293int          HostTableParallelOps   PROTO((SkyList *sky, int argc, char **argv, char *ResultFile, int ReadVectors, int Nelements, int VERBOSE));

  • trunk/Ohana/src/opihi/include/shell.h

    r33662 r37049  
    166166// wrap readline in ohana mem functions:
    167167char         *opihi_readline            PROTO((char *prompt));
     168
     169int set_list_varname (char *line, char *base, int N, int excelStyle);
    168170
    169171/* gprint functions */

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

    r35109 r37049  
    134134  FTable ftable;
    135135
    136   int i, j, k;
     136  int i, j;
    137137  FILE *f = NULL;
    138138
    … …  
    202202    assert (status);
    203203
    204 # define ASSIGN_DATA(TYPE,OPTYPE) \
    205     /* assign the data to the actual vector */ \
    206     if (!strcmp (type, #TYPE)) { \
    207       TYPE *Ptr = data;     \
    208       for (k = 0; k < Nrows; k++) { \
    209         for (j = 0; j < Nval; j++, Ptr++) { \
    210           vec[Nvec + j][0].elements.OPTYPE[k] = *Ptr; \
    211         } } }
    212 
    213     // assign the data to the actual vector
    214     ASSIGN_DATA(char,    Int);
    215     ASSIGN_DATA(short,   Int);
    216     ASSIGN_DATA(int,     Int);
    217     ASSIGN_DATA(int64_t, Int);
    218     ASSIGN_DATA(float,   Flt);
    219     ASSIGN_DATA(double,  Flt);
     204    if (!VectorAssignData(&vec[Nvec], type, data, Nrows, Nval)) {
     205      // free unneeded things
     206      gprint (GP_ERR, "trouble parsing data block type %s\n", type);
     207      return (NULL);
     208    }
    220209
    221210    free (data);
    … …  
    241230//  return (FALSE);
    242231}
     232
     233# define ASSIGN_DATA(TYPE,DTYPE,OPTYPE)        \
     234    /* assign the data to the actual vector */ \
     235    if (!strcmp (type, #TYPE)) { \
     236      DTYPE *Ptr = data;                    \
     237      for (k = 0; k < Nrows; k++) { \
     238        for (j = 0; j < Nval; j++, Ptr++) { \
     239          vec[j][0].elements.OPTYPE[k] = *Ptr; \
     240          } } return TRUE; }
     241
     242int VectorAssignData (Vector **vec, char *type, void *data, int Nrows, int Nval) {
     243
     244  int j, k;
     245
     246  // assign the data to the actual vector
     247  ASSIGN_DATA(byte,    char,    Int);
     248  ASSIGN_DATA(char,    char,    Int);
     249  ASSIGN_DATA(short,   short,   Int);
     250  ASSIGN_DATA(int,     int,     Int);
     251  ASSIGN_DATA(int64_t, int64_t, Int);
     252  ASSIGN_DATA(float,   float,   Flt);
     253  ASSIGN_DATA(double,  double,  Flt);
     254
     255  return FALSE;
     256}
     257
     258# define ASSIGN_DATA_TRANSPOSE(TYPE,DTYPE,OPTYPE)       \
     259    /* assign the data to the actual vector */ \
     260    if (!strcmp (type, #TYPE)) { \
     261      DTYPE *Ptr = data;                    \
     262      for (k = 0; k < Nrows; k++) { \
     263        for (j = 0; j < Nval; j++, Ptr++) { \
     264          vec[k][0].elements.OPTYPE[j] = *Ptr; \
     265          } } return TRUE; }
     266
     267int VectorAssignDataTranspose (Vector **vec, char *type, void *data, int Nrows, int Nval) {
     268
     269  int j, k;
     270
     271  // assign the data to the actual vector
     272  ASSIGN_DATA_TRANSPOSE(byte,    char,    Int);
     273  ASSIGN_DATA_TRANSPOSE(char,    char,    Int);
     274  ASSIGN_DATA_TRANSPOSE(short,   short,   Int);
     275  ASSIGN_DATA_TRANSPOSE(int,     int,     Int);
     276  ASSIGN_DATA_TRANSPOSE(int64_t, int64_t, Int);
     277  ASSIGN_DATA_TRANSPOSE(float,   float,   Flt);
     278  ASSIGN_DATA_TRANSPOSE(double,  double,  Flt);
     279
     280  return FALSE;
     281}

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

    r33662 r37049  
    322322}
    323323
     324int set_list_varname (char *line, char *base, int N, int excelStyle) {
     325
     326  int i;
     327   
     328  // A-Z correspond to 0 - 25
     329
     330  if (excelStyle) {
     331    float f = log(26.0);
     332    float g = (N == 0) ? 0.0 : log(1.0*N);
     333    int Ndigit = (int) (g / f) + 1;
     334    if (Ndigit > 10) {
     335      sprintf (line, "%s:ZZZZZZZZZZ", base);
     336      return FALSE;
     337    }
     338    char name[12];
     339    memset (name, 0, 12);
     340    for (i = 0; i < Ndigit; i++) {
     341      float Npow = Ndigit - i - 1;
     342      float g = pow(26.0, Npow);
     343      int V = (int) (N / g);
     344      name[i] = (Npow == 0.0) ? 'A' + V : 'A' + V - 1;
     345      N -= V * g;
     346    }
     347    sprintf (line, "%s:%s", base, name);
     348  } else {
     349    sprintf (line, "%s:%d", base, N);
     350  }
     351  return TRUE;
     352}
Note: See TracChangeset for help on using the changeset viewer.