IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Apr 16, 2020, 2:04:27 PM (6 years ago)
Author:
tdeboer
Message:

quick undo

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r41340 r41341  
    3535
    3636// vector types
    37 enum {COLTYPE_NONE, COLTYPE_FLT, COLTYPE_INT, COLTYPE_TIME, COLTYPE_CHAR};
     37enum {COLTYPE_NONE, COLTYPE_FLT, COLTYPE_INT, COLTYPE_TIME, COLTYPE_DATE, COLTYPE_CHAR, COLTYPE_STR, COLTYPE_HMS};
    3838
    3939static int      Nvec     = 0;
    … …  
    9191    gprint (GP_ERR, "     -skip N : skip N lines before reading\n");
    9292    gprint (GP_ERR, "     column names may include a type: name:type\n");
    93     gprint (GP_ERR, "       type is int, float, char, time\n");
     93    gprint (GP_ERR, "       type is int, float, char, str, time, date, hms\n");
    9494    gprint (GP_ERR, "       for char, values are placed into a list $name:0 - $name:n\n");
     95    gprint (GP_ERR, "       for str, values are placed into a string-typed vector\n");
     96    gprint (GP_ERR, "       for hms, values are sexigesimal values HH:MM:SS (good for degrees as well)\n");
     97    gprint (GP_ERR, "       for date, values are human-readable date strings YYYY/MM/DD\n");
    9598    gprint (GP_ERR, "       for time, values are human-readable date/time strings YYYY/MM/DD,hh:mm:ss\n");
    96     gprint (GP_ERR, "       the resulting vector is a float based on the TIMEFORMAT, TIMEREF values\n");
     99    gprint (GP_ERR, "         date & time values are stored as a float using the TIMEFORMAT, TIMEREF values for the conversion\n");
    97100
    98101    gprint (GP_ERR, "     -fits options:\n");
    … …  
    152155      if (!strcasecmp(ptr, "int"))   { coltype[i] = COLTYPE_INT; }
    153156      if (!strcasecmp(ptr, "char"))  { coltype[i] = COLTYPE_CHAR; }
     157      if (!strcasecmp(ptr, "str"))   { coltype[i] = COLTYPE_STR; }
     158      if (!strcasecmp(ptr, "date"))  { coltype[i] = COLTYPE_DATE; }
    154159      if (!strcasecmp(ptr, "time"))  { coltype[i] = COLTYPE_TIME; }
     160      if (!strcasecmp(ptr, "hms"))   { coltype[i] = COLTYPE_HMS; }
    155161      if (!coltype[i]) goto bad_colname;
    156162    }
    … …  
    210216        break;
    211217      case COLTYPE_FLT:
     218      case COLTYPE_HMS:
    212219      case COLTYPE_TIME:
    213         // note that COLTYPE_TIME is a type of float
     220      case COLTYPE_DATE:
    214221        ResetVector (vec[i], OPIHI_FLT, NELEM);
     222        break;
     223      case COLTYPE_STR:
     224        ResetVector (vec[i], OPIHI_STR, NELEM);
    215225        break;
    216226      case COLTYPE_CHAR:
    … …  
    287297        time_t tvalue;
    288298        int readStatus = FALSE;
     299        int dataStatus = FALSE;
    289300        // need to make the if cases for coltype[i]
    290301        switch (coltype[i]) {
    … …  
    311322              break;
    312323            }
     324          case COLTYPE_STR:
     325            {
     326              // I need to get an isolated word in 'value' with the string value of this field
     327              char *ptr = IsCSV ? ptrparse_csv (col[i], c0) : ptrparse (col[i], c0);
     328              char *value = NULL;
     329              if (IsCSV) {
     330                char *end = parse_nextword_csv (ptr);
     331                if (end) {
     332                  value = end ? strncreate (ptr, end - ptr) : strcreate (ptr);
     333                }
     334              } else {
     335                value = thisword(ptr);
     336              }
     337              vec[i][0].elements.Str[Nelem] = value; // needs to be freed later.
     338              break;
     339            }
    313340          case COLTYPE_FLT:
    314341            readStatus = IsCSV ? dparse_csv (&dvalue, col[i], c0) : dparse (&dvalue, col[i], c0);
    … …  
    320347            vec[i][0].elements.Flt[Nelem] = readStatus ? dvalue : NAN;
    321348            break;
     349          case COLTYPE_DATE: {
     350            char *string = NULL;
     351            if (IsCSV) {
     352              char *ptr = ptrparse_csv (col[i], c0);
     353              string = strcreate (ptr); // create separate string (NULL-safe)
     354              ptr = (string == NULL) ? NULL : strchr (string, ',');
     355              if (ptr != NULL) *ptr = 0; // place an EOL here so parsing does not go past the comma
     356            } else {
     357              char *ptr = ptrparse (col[i], c0); // NULL-safe
     358              string = getword (ptr); // NULL-safe
     359            }         
     360            tvalue = ohana_date_to_sec (string); // NULL-safe (returns 0)
     361            dvalue = TimeValue (tvalue, TimeReference, TimeFormat);
     362            vec[i][0].elements.Flt[Nelem] = string ? dvalue : NAN;
     363            FREE (string);
     364            break;
     365          }
     366          case COLTYPE_HMS: {
     367            char *ptr = IsCSV ? ptrparse_csv (col[i], c0) : ptrparse (col[i], c0);
     368            char *string = strcreate (ptr); // make a copy so we can munge it in ohana_dms_to_ddd
     369            dataStatus = ohana_dms_to_ddd (&dvalue, string);
     370            vec[i][0].elements.Flt[Nelem] = ((string != NULL) && dataStatus) ? dvalue : NAN;
     371            FREE (string);
     372            break;
     373          }
    322374        }
    323375        if (!readStatus && VERBOSE) {
    … …  
    345397              break;
    346398            case COLTYPE_FLT:
     399            case COLTYPE_HMS:
    347400            case COLTYPE_TIME:
     401            case COLTYPE_DATE:
    348402              ResetVector (vec[i], OPIHI_FLT, NELEM);
     403              break;
     404            case COLTYPE_STR:
     405              ResetVector (vec[i], OPIHI_STR, NELEM);
    349406              break;
    350407            case COLTYPE_CHAR:
    … …  
    366423        break;
    367424      case COLTYPE_FLT:
     425      case COLTYPE_HMS:
    368426      case COLTYPE_TIME:
     427      case COLTYPE_DATE:
    369428        ResetVector (vec[i], OPIHI_FLT, Nelem);
     429        break;
     430      case COLTYPE_STR:
     431        ResetVector (vec[i], OPIHI_STR, Nelem);
    370432        break;
    371433      case COLTYPE_CHAR:
    … …  
    469531  }
    470532
    471   // if CharAsVectors, char fields will be saved as vectors NAME:0 -- NAME:n for n characters
    472   // else char fields will be saved as $NAME:0 - $NAME:m for m rows
     533  // by default, we now store a string-type field as a string-type vector.
     534
     535  // if CharAsList is selected (and My < 10000), char fields will be saved as $NAME:0 - $NAME:m for m rows
     536
     537  // if CharAsVectors is selected, char fields will be saved as vectors NAME:0 -- NAME:n for n characters
     538
    473539  // if (Ny > 10000), force CharAsVectors
    474540  int CharAsVectors = FALSE;
    … …  
    476542    remove_argument (N, &argc, argv);
    477543    CharAsVectors = TRUE;
     544  }
     545  int CharAsList = FALSE;
     546  if ((N = get_argument (argc, argv, "-char-list"))) {
     547    remove_argument (N, &argc, argv);
     548    CharAsList = TRUE;
    478549  }
    479550
    … …  
    651722    if (!FITS_TRANSPOSE) {
    652723      // read string column into a list rather than a vector
    653       if (!strcmp (type, "char") && !CharAsVectors && (Ny < 3000)) {
    654         char *fieldName = argv[i];
    655         char *Ptr = data;
    656         char varname[1024];  // used as a buffer for the names of string fields
    657         for (j = 0; j < Ny; j++) {
    658           set_list_varname (varname, fieldName, j, FALSE);
    659           char *value = strncreate (&Ptr[j*Nval], Nval);
    660           // replace instances of $ with _
    661           char *p = strchr (value, '$');
    662           while (p) {
    663             *p = '_';
    664             p = strchr (p, '$');
     724      if (!strcmp (type, "char")) {
     725        // save char-type field as a List:
     726        if (CharAsList && (Ny < 3000)) {
     727          char *fieldName = argv[i];
     728          char *Ptr = data;
     729          char varname[1024];  // used as a buffer for the names of string fields
     730          for (j = 0; j < Ny; j++) {
     731            set_list_varname (varname, fieldName, j, FALSE);
     732            char *value = strncreate (&Ptr[j*Nval], Nval);
     733            // replace instances of $ with _
     734            char *p = strchr (value, '$');
     735            while (p) {
     736              *p = '_';
     737              p = strchr (p, '$');
     738            }
     739            set_str_variable (varname, value);
     740            free (value);
    665741          }
    666           set_str_variable (varname, value);
    667           free (value);
     742          sprintf (varname, "%s:n", fieldName);
     743          set_int_variable (varname, Ny);
     744          continue;
    668745        }
    669         sprintf (varname, "%s:n", fieldName);
    670         set_int_variable (varname, Ny);
    671         continue;
     746        // save char-type field as a string-type vector:
     747        if (!CharAsVectors) {
     748          Vector *myVector = NULL;
     749          sprintf (name, "%s", argv[i]);
     750          if ((myVector = SelectVector (name, ANYVECTOR, TRUE)) == NULL) ESCAPE ("bad vector name\n");
     751          ResetVector (myVector, OPIHI_STR, Ny);
     752
     753          char *Ptr = data;
     754          for (j = 0; j < Ny; j++) {
     755            myVector[0].elements.Str[j] = strncreate (&Ptr[j*Nval], Nval);
     756            // replace instances of $ with _
     757            char *p = strchr (myVector[0].elements.Str[j], '$');
     758            while (p) { *p = '_'; p = strchr (p, '$'); }
     759          }
     760          continue;
     761        }
    672762      }
    673763
    674764      // define the multifield vector names (Nval vectors x Ny elements)
     765      // CharAsVectors is handled below automatically
    675766      ALLOCATE (vec, Vector *, Nval);
    676767      for (j = 0; j < Nval; j++) {
Note: See TracChangeset for help on using the changeset viewer.