IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Apr 16, 2020, 1:54:47 PM (6 years ago)
Author:
tdeboer
Message:

revert to working Ohana build

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r41305 r41340  
    3535
    3636// vector types
    37 enum {COLTYPE_NONE, COLTYPE_FLT, COLTYPE_INT, COLTYPE_TIME, COLTYPE_DATE, COLTYPE_CHAR, COLTYPE_STR, COLTYPE_HMS};
     37enum {COLTYPE_NONE, COLTYPE_FLT, COLTYPE_INT, COLTYPE_TIME, COLTYPE_CHAR};
    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, str, time, date, hms\n");
     93    gprint (GP_ERR, "       type is int, float, char, time\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");
    9895    gprint (GP_ERR, "       for time, values are human-readable date/time strings YYYY/MM/DD,hh:mm:ss\n");
    99     gprint (GP_ERR, "         date & time values are stored as a float using the TIMEFORMAT, TIMEREF values for the conversion\n");
     96    gprint (GP_ERR, "       the resulting vector is a float based on the TIMEFORMAT, TIMEREF values\n");
    10097
    10198    gprint (GP_ERR, "     -fits options:\n");
    … …  
    155152      if (!strcasecmp(ptr, "int"))   { coltype[i] = COLTYPE_INT; }
    156153      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; }
    159154      if (!strcasecmp(ptr, "time"))  { coltype[i] = COLTYPE_TIME; }
    160       if (!strcasecmp(ptr, "hms"))   { coltype[i] = COLTYPE_HMS; }
    161155      if (!coltype[i]) goto bad_colname;
    162156    }
    … …  
    216210        break;
    217211      case COLTYPE_FLT:
    218       case COLTYPE_HMS:
    219212      case COLTYPE_TIME:
    220       case COLTYPE_DATE:
     213        // note that COLTYPE_TIME is a type of float
    221214        ResetVector (vec[i], OPIHI_FLT, NELEM);
    222         break;
    223       case COLTYPE_STR:
    224         ResetVector (vec[i], OPIHI_STR, NELEM);
    225215        break;
    226216      case COLTYPE_CHAR:
    … …  
    297287        time_t tvalue;
    298288        int readStatus = FALSE;
    299         int dataStatus = FALSE;
    300289        // need to make the if cases for coltype[i]
    301290        switch (coltype[i]) {
    … …  
    322311              break;
    323312            }
    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             }
    340313          case COLTYPE_FLT:
    341314            readStatus = IsCSV ? dparse_csv (&dvalue, col[i], c0) : dparse (&dvalue, col[i], c0);
    … …  
    347320            vec[i][0].elements.Flt[Nelem] = readStatus ? dvalue : NAN;
    348321            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           }
    374322        }
    375323        if (!readStatus && VERBOSE) {
    … …  
    397345              break;
    398346            case COLTYPE_FLT:
    399             case COLTYPE_HMS:
    400347            case COLTYPE_TIME:
    401             case COLTYPE_DATE:
    402348              ResetVector (vec[i], OPIHI_FLT, NELEM);
    403               break;
    404             case COLTYPE_STR:
    405               ResetVector (vec[i], OPIHI_STR, NELEM);
    406349              break;
    407350            case COLTYPE_CHAR:
    … …  
    423366        break;
    424367      case COLTYPE_FLT:
    425       case COLTYPE_HMS:
    426368      case COLTYPE_TIME:
    427       case COLTYPE_DATE:
    428369        ResetVector (vec[i], OPIHI_FLT, Nelem);
    429         break;
    430       case COLTYPE_STR:
    431         ResetVector (vec[i], OPIHI_STR, Nelem);
    432370        break;
    433371      case COLTYPE_CHAR:
    … …  
    531469  }
    532470
    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 
     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
    539473  // if (Ny > 10000), force CharAsVectors
    540474  int CharAsVectors = FALSE;
    … …  
    542476    remove_argument (N, &argc, argv);
    543477    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;
    549478  }
    550479
    … …  
    722651    if (!FITS_TRANSPOSE) {
    723652      // read string column into a list rather than a vector
    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);
     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, '$');
    741665          }
    742           sprintf (varname, "%s:n", fieldName);
    743           set_int_variable (varname, Ny);
    744           continue;
     666          set_str_variable (varname, value);
     667          free (value);
    745668        }
    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         }
     669        sprintf (varname, "%s:n", fieldName);
     670        set_int_variable (varname, Ny);
     671        continue;
    762672      }
    763673
    764674      // define the multifield vector names (Nval vectors x Ny elements)
    765       // CharAsVectors is handled below automatically
    766675      ALLOCATE (vec, Vector *, Nval);
    767676      for (j = 0; j < Nval; j++) {
Note: See TracChangeset for help on using the changeset viewer.