long get_material_property(char *label, char *property, char **str_value, long *int_value, double *double_value) { long rows=0, index, col_index=-1; SDDS_DATASET table; int32_t *intValue = NULL; char **formula, **name; double *doubleValue = NULL; formula = name = NULL; if ((col_index=match_string(property, table_column, TABLE_COLS, 0))<0) { if (verbose) fprintf(stderr, "Property - %s does not exist in the property table.\n", property); return -1; } if (!SDDS_InitializeInput(&table, matTable)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_ReadPage(&table) || !(rows=SDDS_CountRowsOfInterest(&table)) || !(formula=(char**)SDDS_GetColumn(&table, "Formula")) || !(name=(char**)SDDS_GetColumn(&table, "Name"))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); index = match_string(label, formula, rows, EXACT_MATCH); if (index<0) index = match_string(label, name, rows, 0); if (index<0) { fprintf(stdout, "%s not found.\n", label); return -1; } switch (col_index) { case FORMULA_COL: SDDS_CopyString(str_value, formula[index]); break; case NAME_COL: SDDS_CopyString(str_value, name[index]); break; case Z_COL: case GROUP_COL: case PERIOD_COL: intValue = (int32_t*)SDDS_GetColumn(&table, table_column[col_index]); *int_value = intValue[index]; free(intValue); break; default: doubleValue = (double*)SDDS_GetColumn(&table, table_column[col_index]); *double_value = doubleValue[index]; free(doubleValue); break; } if (!SDDS_Terminate(&table)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); SDDS_FreeStringArray(formula, rows); SDDS_FreeStringArray(name, rows); free(formula); free(name); return index; }
int main(int argc, char **argv) { FILE *fileID; COLUMN_DATA_STRUCTURES *columnValues; PARAMETER_DATA_STRUCTURES *parameterValues; SDDS_DATASET SDDS_dataset; SCANNED_ARG *s_arg; long i, j, k, n, i_arg; int32_t rows; int32_t maxRows=10000, initRows=10000, row; long par, col, page, size, readline=1, fillin=0; int32_t ptrSize=0; char *input, *output, s[1024], *ptr, *ptr2, data[10240],temp[10240]; unsigned long pipeFlags=0,majorOrderFlag; long noWarnings=0, tmpfile_used=0, columnOrder=0, whitespace=1; short shortValue; int32_t longValue; float floatValue; double doubleValue; char stringValue[SDDS_MAXLINE]; char characterValue; char buffer[124], buffer2[124]; long *parameterIndex, *columnIndex; long binary=0, noRowCount=0, inputBinary=0, count=0; char separator; char commentCharacters[20]; short checkComment=0; short commentFound; long parameters=0, columns=0; long skiplines=0; short abort=0, recover=1, columnMajorOrder=0; input = output = NULL; separator = ' '; columnValues = NULL; parameterValues = NULL; parameterIndex = columnIndex = NULL; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc<3) bomb(NULL, USAGE); for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) { case SET_MAJOR_ORDER: majorOrderFlag=0; s_arg[i_arg].n_items -=1; if (s_arg[i_arg].n_items>0 && (!scanItemList(&majorOrderFlag, s_arg[i_arg].list+1, &s_arg[i_arg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) SDDS_Bomb("invalid -majorOrder syntax/values"); if (majorOrderFlag&SDDS_COLUMN_MAJOR_ORDER) columnMajorOrder=1; else if (majorOrderFlag&SDDS_ROW_MAJOR_ORDER) columnMajorOrder=0; break; case SET_OUTPUTMODE: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -outputMode syntax"); switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) { case ASCII_MODE: binary = 0; break; case BINARY_MODE: binary = 1; break; default: SDDS_Bomb("invalid -outputMode syntax"); break; } break; case SET_INPUTMODE: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -inputMode syntax"); switch (match_string(s_arg[i_arg].list[1], mode_name, MODES, 0)) { case ASCII_MODE: inputBinary = 0; break; case BINARY_MODE: inputBinary = 1; break; default: SDDS_Bomb("invalid -inputMode syntax"); break; } break; case SET_SEPARATOR: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -separator syntax"); separator = s_arg[i_arg].list[1][0]; whitespace = 0; break; case SET_COMMENT: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -commentCharacters syntax"); sprintf(commentCharacters, "%s", s_arg[i_arg].list[1]); checkComment=1; break; case SET_FILLIN: fillin=1; break; case SET_NOROWCOUNT: if (s_arg[i_arg].n_items!=1) SDDS_Bomb("invalid -noRowCount syntax"); noRowCount = 1; break; case SET_ORDER: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -order syntax"); switch (match_string(s_arg[i_arg].list[1], order_names, ORDERS, 0)) { case ROW_ORDER: columnOrder = 0; break; case COLUMN_ORDER: columnOrder = 1; break; default: SDDS_Bomb("invalid -order syntax"); break; } break; case SET_PARAMETER: if (s_arg[i_arg].n_items<3) SDDS_Bomb("invalid -parameter syntax"); count=1; parameters++; parameterValues = trealloc(parameterValues, sizeof(*parameterValues)*(parameters)); SDDS_CopyString(¶meterValues[parameters-1].name, s_arg[i_arg].list[1]); parameterValues[parameters-1].units = NULL; parameterValues[parameters-1].description = NULL; parameterValues[parameters-1].symbol = NULL; switch (match_string(s_arg[i_arg].list[2], type_name, DATATYPES, 0)) { case TYPE_SHORT: parameterValues[parameters-1].type = SDDS_SHORT; break; case TYPE_LONG: parameterValues[parameters-1].type = SDDS_LONG; break; case TYPE_FLOAT: parameterValues[parameters-1].type = SDDS_FLOAT; break; case TYPE_DOUBLE: parameterValues[parameters-1].type = SDDS_DOUBLE; break; case TYPE_STRING: parameterValues[parameters-1].type = SDDS_STRING; break; case TYPE_CHARACTER: parameterValues[parameters-1].type = SDDS_CHARACTER; break; default: SDDS_Bomb("invalid -parameter type"); break; } for (i=3;i<s_arg[i_arg].n_items;i++) { if (!(ptr=strchr(s_arg[i_arg].list[i], '='))) SDDS_Bomb("invalid -parameter syntax"); *ptr++ = 0; switch (match_string(s_arg[i_arg].list[i], header_elements, HEADERELEMENTS, 0)) { case HEADER_UNITS: SDDS_CopyString(¶meterValues[parameters-1].units, ptr); break; case HEADER_DESCRIPTION: SDDS_CopyString(¶meterValues[parameters-1].description, ptr); break; case HEADER_SYMBOL: SDDS_CopyString(¶meterValues[parameters-1].symbol, ptr); break; case HEADER_COUNT: if (sscanf(ptr, "%ld", &count)!=1 || count<=0) SDDS_Bomb("invalid parameter count value"); sprintf(buffer, "%s", parameterValues[parameters-1].name); sprintf(buffer2, "%s1", buffer); free(parameterValues[parameters-1].name); SDDS_CopyString(¶meterValues[parameters-1].name, buffer2); break; default: SDDS_Bomb("invalid -parameter syntax"); break; } } for (i=2;i<=count;i++) { parameters++; parameterValues = trealloc(parameterValues, sizeof(*parameterValues)*(parameters)); sprintf(buffer2, "%s%ld", buffer, i); SDDS_CopyString(¶meterValues[parameters-1].name, buffer2); parameterValues[parameters-1].units = NULL; parameterValues[parameters-1].description = NULL; parameterValues[parameters-1].symbol = NULL; parameterValues[parameters-1].type = parameterValues[parameters-2].type; if (parameterValues[parameters-2].units) SDDS_CopyString(¶meterValues[parameters-1].units, parameterValues[parameters-2].units); if (parameterValues[parameters-2].description) SDDS_CopyString(¶meterValues[parameters-1].description, parameterValues[parameters-2].description); if (parameterValues[parameters-2].symbol) SDDS_CopyString(¶meterValues[parameters-1].symbol, parameterValues[parameters-2].symbol); } break; case SET_COLUMN: if (s_arg[i_arg].n_items<3) SDDS_Bomb("invalid -column syntax"); count=1; columns++; columnValues = trealloc(columnValues, sizeof(*columnValues)*(columns)); SDDS_CopyString(&columnValues[columns-1].name, s_arg[i_arg].list[1]); columnValues[columns-1].elements = 0; columnValues[columns-1].values = NULL; columnValues[columns-1].stringValues = NULL; columnValues[columns-1].units = NULL; columnValues[columns-1].description = NULL; columnValues[columns-1].symbol = NULL; columnValues[columns-1].skip = 0; switch (match_string(s_arg[i_arg].list[2], type_name, DATATYPES, 0)) { case TYPE_SHORT: columnValues[columns-1].type = SDDS_SHORT; break; case TYPE_LONG: columnValues[columns-1].type = SDDS_LONG; break; case TYPE_FLOAT: columnValues[columns-1].type = SDDS_FLOAT; break; case TYPE_DOUBLE: columnValues[columns-1].type = SDDS_DOUBLE; break; case TYPE_STRING: columnValues[columns-1].type = SDDS_STRING; break; case TYPE_CHARACTER: columnValues[columns-1].type = SDDS_CHARACTER; break; default: SDDS_Bomb("invalid -column type"); break; } for (i=3;i<s_arg[i_arg].n_items;i++) { if (!(ptr=strchr(s_arg[i_arg].list[i], '='))) SDDS_Bomb("invalid -column syntax"); *ptr++ = 0; switch (match_string(s_arg[i_arg].list[i], header_elements, HEADERELEMENTS, 0)) { case HEADER_UNITS: SDDS_CopyString(&columnValues[columns-1].units, ptr); break; case HEADER_DESCRIPTION: SDDS_CopyString(&columnValues[columns-1].description, ptr); break; case HEADER_SYMBOL: SDDS_CopyString(&columnValues[columns-1].symbol, ptr); break; case HEADER_COUNT: if (sscanf(ptr, "%ld", &count)!=1 || count<=0) SDDS_Bomb("invalid column count value"); sprintf(buffer, "%s", columnValues[columns-1].name); sprintf(buffer2, "%s1", buffer); free(columnValues[columns-1].name); SDDS_CopyString(&columnValues[columns-1].name, buffer2); break; default: SDDS_Bomb("invalid -column syntax"); break; } } for (i=2;i<=count;i++) { columns++; columnValues = trealloc(columnValues, sizeof(*columnValues)*(columns)); sprintf(buffer2, "%s%ld", buffer, i); SDDS_CopyString(&columnValues[columns-1].name, buffer2); columnValues[columns-1].elements = 0; columnValues[columns-1].values = NULL; columnValues[columns-1].stringValues = NULL; columnValues[columns-1].units = NULL; columnValues[columns-1].description = NULL; columnValues[columns-1].symbol = NULL; columnValues[columns-1].type = columnValues[columns-2].type; if (columnValues[columns-2].units) SDDS_CopyString(&columnValues[columns-1].units, columnValues[columns-2].units); if (columnValues[columns-2].description) SDDS_CopyString(&columnValues[columns-1].description, columnValues[columns-2].description); if (columnValues[columns-2].symbol) SDDS_CopyString(&columnValues[columns-1].symbol, columnValues[columns-2].symbol); } break; case SET_SKIPCOLUMN: if (s_arg[i_arg].n_items!=2) SDDS_Bomb("invalid -skipcolumn syntax"); count=1; columns++; columnValues = trealloc(columnValues, sizeof(*columnValues)*(columns)); columnValues[columns-1].name = NULL; columnValues[columns-1].elements = 0; columnValues[columns-1].values = NULL; columnValues[columns-1].stringValues = NULL; columnValues[columns-1].units = NULL; columnValues[columns-1].description = NULL; columnValues[columns-1].symbol = NULL; columnValues[columns-1].skip = 1; switch (match_string(s_arg[i_arg].list[1], type_name, DATATYPES, 0)) { case TYPE_SHORT: columnValues[columns-1].type = SDDS_SHORT; break; case TYPE_LONG: columnValues[columns-1].type = SDDS_LONG; break; case TYPE_FLOAT: columnValues[columns-1].type = SDDS_FLOAT; break; case TYPE_DOUBLE: columnValues[columns-1].type = SDDS_DOUBLE; break; case TYPE_STRING: columnValues[columns-1].type = SDDS_STRING; break; case TYPE_CHARACTER: columnValues[columns-1].type = SDDS_CHARACTER; break; default: SDDS_Bomb("invalid -skipcolumn type"); break; } break; case SET_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case SET_NOWARNINGS: if (s_arg[i_arg].n_items!=1) SDDS_Bomb("invalid -nowarnings syntax"); noWarnings = 1; break; case SET_SKIPLINES: if (s_arg[i_arg].n_items!=2 || sscanf(s_arg[i_arg].list[1], "%ld", &skiplines)!=1 || skiplines<=0) SDDS_Bomb("invalid -skiplines syntax"); break; default: fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]); exit(1); break; } } else { if (input == NULL) { input = s_arg[i_arg].list[0]; } else if (output == NULL) { output = s_arg[i_arg].list[0]; } else { fprintf(stderr, "too many filenames"); exit(1); } } } processFilenames("plaindata2sdds", &input, &output, pipeFlags, noWarnings, &tmpfile_used); if (!columns && !parameters) SDDS_Bomb("you must specify one of the -column or the -parameter options"); if (skiplines && inputBinary) SDDS_Bomb("-skiplines does not work with binary input files"); if (!input) { if (inputBinary) { #if defined(_WIN32) if (_setmode(_fileno(stdin), _O_BINARY) == -1) { fprintf(stderr, "error: unable to set stdin to binary mode\n"); exit(1); } #endif } fileID = stdin; } else { if (!fexists(input)) { fprintf(stderr, "input file not found\n"); exit(1); } if (inputBinary) { fileID = fopen(input, "rb"); } else { fileID = fopen(input, "r"); } } if (fileID == NULL) { fprintf(stderr, "unable to open input file for reading\n"); exit(1); } if (!SDDS_InitializeOutput(&SDDS_dataset, binary?SDDS_BINARY:SDDS_ASCII, 1, NULL, NULL, output)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); SDDS_dataset.layout.data_mode.column_major = columnMajorOrder; if (parameters) { parameterIndex = tmalloc(sizeof(*parameterIndex)*parameters); } if (columns) { columnIndex = tmalloc(sizeof(*columnIndex)*columns); } for (i=0; i<parameters; i++) { if ((parameterIndex[i] = SDDS_DefineParameter(&SDDS_dataset, parameterValues[i].name, parameterValues[i].symbol, parameterValues[i].units, parameterValues[i].description, NULL, parameterValues[i].type, 0))<0) { sprintf(s, "Problem defining parameter %s.", parameterValues[i].name); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } for (i=0; i<columns; i++) { if (columnValues[i].skip) continue; if ((columnIndex[i] = SDDS_DefineColumn(&SDDS_dataset, columnValues[i].name, columnValues[i].symbol, \ columnValues[i].units, columnValues[i].description, NULL, columnValues[i].type, 0))<0) { sprintf(s, "Problem defining column %s.", columnValues[i].name); SDDS_SetError(s); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (!SDDS_WriteLayout(&SDDS_dataset)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_StartPage(&SDDS_dataset, initRows)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); row = par = col = page = 0; while (inputBinary) { row = par = col = 0; if (fread(&rows,sizeof(rows),1,fileID) != 1) { if (page == 0) { SDDS_SetError("Unable to read number of rows"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (!SDDS_Terminate(&SDDS_dataset)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for (k=0;k<columns;k++) { if (columnValues[k].type == SDDS_STRING) { SDDS_FreeStringArray(columnValues[k].stringValues,columnValues[k].elements); } else { free(columnValues[k].values); } } return 0; } } page++; for (par=0;par<parameters;par++) { switch (parameterValues[par].type) { case SDDS_SHORT: if (fread(&shortValue,2,1,fileID) != 1) { SDDS_SetError("Unable to read short parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,shortValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_LONG: if (fread(&longValue,4,1,fileID) != 1) { SDDS_SetError("Unable to read long parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,longValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_FLOAT: if (fread(&floatValue,4,1,fileID) != 1) { SDDS_SetError("Unable to read float parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,floatValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_DOUBLE: if (fread(&doubleValue,8,1,fileID) != 1) { SDDS_SetError("Unable to read double parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,doubleValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_STRING: if (fread(&size,4,1,fileID) != 1) { SDDS_SetError("Unable to read string parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (size>SDDS_MAXLINE-1) SDDS_Bomb("String is too long"); if (size > 0) { if (fread(&stringValue,size,1,fileID) != 1) { SDDS_SetError("Unable to read string parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } stringValue[size] = 0; } else { strcpy(stringValue,""); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,stringValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_CHARACTER: if (fread(&characterValue,1,1,fileID) != 1) { SDDS_SetError("Unable to read character parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,characterValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; } } for (i=0;i<columns;i++) { if (rows > columnValues[i].elements) { if (columnValues[i].type == SDDS_STRING) { columnValues[i].stringValues = AllocateColumnStringData(columnValues[i].stringValues, rows, columnValues[i].elements); } else { columnValues[i].values = AllocateColumnData(columnValues[i].type, columnValues[i].values, rows); } columnValues[i].elements = rows; } } if (columnOrder) { for (col=0;col<columns;col++) { switch (columnValues[col].type) { case SDDS_SHORT: for (i=0;i<rows;i++) { if (fread((short*)(columnValues[col].values)+i,2,1,fileID) != 1) { SDDS_SetError("Unable to read short column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_LONG: for (i=0;i<rows;i++) { if (fread((int32_t*)(columnValues[col].values)+i,4,1,fileID) != 1) { SDDS_SetError("Unable to read long column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_FLOAT: for (i=0;i<rows;i++) { if (fread((float*)(columnValues[col].values)+i,4,1,fileID) != 1) { SDDS_SetError("Unable to read float column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_DOUBLE: for (i=0;i<rows;i++) { if (fread((double*)(columnValues[col].values)+i,8,1,fileID) != 1) { SDDS_SetError("Unable to read double double"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_STRING: for (i=0;i<rows;i++) { if (fread(&size,4,1,fileID) != 1) { SDDS_SetError("Unable to read string column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (size>SDDS_MAXLINE-1) SDDS_Bomb("String is too long"); columnValues[col].stringValues[i] = malloc(size + 1); if (size > 0) { if (fread(columnValues[col].stringValues[i],size,1,fileID) != 1) { SDDS_SetError("Unable to read string column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } columnValues[col].stringValues[i][size] = 0; } else { strcpy(columnValues[col].stringValues[i],""); } } break; case SDDS_CHARACTER: for (i=0;i<rows;i++) { if (fread((char*)(columnValues[col].values)+i,1,1,fileID) != 1) { SDDS_SetError("Unable to read character column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; } } } else { for (i=0;i<rows;i++) { for (col=0;col<columns;col++) { switch (columnValues[col].type) { case SDDS_SHORT: if (fread((short*)(columnValues[col].values)+i,2,1,fileID) != 1) { SDDS_SetError("Unable to read short column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } break; case SDDS_LONG: if (fread((int32_t*)(columnValues[col].values)+i,4,1,fileID) != 1) { SDDS_SetError("Unable to read long column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } break; case SDDS_FLOAT: if (fread((float*)(columnValues[col].values)+i,4,1,fileID) != 1) { SDDS_SetError("Unable to read float column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } break; case SDDS_DOUBLE: if (fread(((double*)(columnValues[col].values)+i),8,1,fileID) != 1) { SDDS_SetError("Unable to read double column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } break; case SDDS_STRING: if (fread(&size,4,1,fileID) != 1) { SDDS_SetError("Unable to read string column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (size>SDDS_MAXLINE-1) SDDS_Bomb("String is too long"); columnValues[col].stringValues[i] = malloc(size + 1); if (size > 0) { if (fread(columnValues[col].stringValues[i],size,1,fileID) != 1) { SDDS_SetError("Unable to read string column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } columnValues[col].stringValues[i][size] = 0; } else { strcpy(columnValues[col].stringValues[i],""); } break; case SDDS_CHARACTER: if (fread(((char*)(columnValues[col].values)+i),1,1,fileID) != 1) { SDDS_SetError("Unable to read character column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } break; } } } } if (rows > maxRows) { if (!SDDS_LengthenTable(&SDDS_dataset, rows - maxRows)) { SDDS_SetError("Unable to lengthen table"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = rows; } j=n; for (i=0;i<columns;i++) { if (columnValues[i].skip) continue; if (columnValues[i].type == SDDS_STRING) { SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].stringValues, rows, n); } else { SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].values, rows, n); } n++; } if (!SDDS_WritePage(&SDDS_dataset)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = 10000; if (!SDDS_StartPage(&SDDS_dataset, initRows)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } row = par = col = n = 0; rows = -1; ptr = NULL; ptr = SDDS_Malloc(sizeof(*ptr)*(ptrSize=2048)); /* ptr2 = NULL; ptr2 = SDDS_Malloc(sizeof(*ptr)*(ptrSize=2048));*/ ptr[0] = 0; while (1) { if (readline) { while (skiplines > 0) { fgets(ptr, ptrSize, fileID); skiplines--; } if (!fgetsSkipCommentsResize(&ptr,&ptrSize,fileID, '!')) break; commentFound=0; if (checkComment) { for (i=0; i<strlen(commentCharacters); i++) { if (ptr[0] == commentCharacters[i]) { commentFound=1; } } } if (commentFound == 1) { continue; } if (ptr[strlen(ptr)-1] == '\n') ptr[strlen(ptr)-1] = 0; strcpy(temp,ptr); /*skip empty lines*/ if (getToken(temp,data,10240,separator,whitespace)<0) continue; } else { readline = 1; } if (par < parameters) { switch (parameterValues[par].type) { case SDDS_SHORT: if (sscanf(ptr,"%hd",&shortValue) != 1) { SDDS_SetError("Invalid short parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,shortValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_LONG: if (sscanf(ptr,"%" SCNd32 ,&longValue) != 1) { SDDS_SetError("Invalid long parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,longValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_FLOAT: ConvertDNotationToENotation(ptr); if (sscanf(ptr,"%f",&floatValue) != 1) { SDDS_SetError("Invalid float parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,floatValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_DOUBLE: ConvertDNotationToENotation(ptr); if (sscanf(ptr,"%lf",&doubleValue) != 1) { SDDS_SetError("Invalid double parameter"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,doubleValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_STRING: SDDS_GetToken(ptr,stringValue,SDDS_MAXLINE); SDDS_InterpretEscapes(stringValue); if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,stringValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; case SDDS_CHARACTER: SDDS_InterpretEscapes(ptr); characterValue = ptr[0]; if (!SDDS_SetParameters(&SDDS_dataset,SDDS_SET_BY_INDEX|SDDS_PASS_BY_VALUE,par,characterValue,-1)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; } par++; } else if ((rows == -1) && (!noRowCount)) { if (sscanf(ptr,"%ld",&rows) != 1) { SDDS_SetError("Invalid row count"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } else if ((columns > 0) && ((row < rows) || (noRowCount))) { if (columnOrder) { if (noRowCount) { cp_str(&ptr2,ptr); rows = 0; while (getToken(ptr2,data,10240,separator,whitespace) >= 0) { rows++; } free(ptr2); } if (rows > columnValues[col].elements) { if (columnValues[col].type == SDDS_STRING) { columnValues[col].stringValues = AllocateColumnStringData(columnValues[col].stringValues, rows, columnValues[col].elements); } else { columnValues[col].values = AllocateColumnData(columnValues[col].type, columnValues[col].values, rows); } columnValues[col].elements = rows; } switch (columnValues[col].type) { case SDDS_SHORT: for (row=0;row<rows;row++) { if (getToken(ptr,data,10240,separator,whitespace) < 0) { SDDS_SetError("Invalid short column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (sscanf(data,"%hd",((short*)(columnValues[col].values)+row)) != 1) { SDDS_SetError("Invalid short column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_LONG: for (row=0;row<rows;row++) { if (getToken(ptr,data,10240,separator,whitespace) < 0) { SDDS_SetError("Invalid long column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (sscanf(data,"%" SCNd32,((int32_t*)(columnValues[col].values)+row)) != 1) { SDDS_SetError("Invalid long column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_FLOAT: for (row=0;row<rows;row++) { if (getToken(ptr,data,10240,separator,whitespace) < 0) { SDDS_SetError("Invalid float column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } ConvertDNotationToENotation(data); if (sscanf(data,"%f",((float*)(columnValues[col].values)+row)) != 1) { SDDS_SetError("Invalid float column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_DOUBLE: for (row=0;row<rows;row++) { if (getToken(ptr,data,10240,separator,whitespace) < 0) { SDDS_SetError("Invalid double column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } ConvertDNotationToENotation(data); if (sscanf(data,"%lf",((double*)(columnValues[col].values)+row)) != 1) { SDDS_SetError("Invalid double column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_STRING: for (row=0;row<rows;row++) { if (getToken(ptr,data,10240,separator,whitespace) < 0) { SDDS_SetError("Invalid string column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } SDDS_InterpretEscapes(data); columnValues[col].stringValues[row] = malloc(strlen(data) + 1); strcpy(columnValues[col].stringValues[row],data); } break; case SDDS_CHARACTER: for (row=0;row<rows;row++) { if (getToken(ptr,data,10240,separator,whitespace) < 0) { SDDS_SetError("Invalid character column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } SDDS_InterpretEscapes(data); *((char*)(columnValues[col].values)+row) = data[0]; } break; } if (rows > maxRows) { if (!SDDS_LengthenTable(&SDDS_dataset, rows - maxRows)) { SDDS_SetError("Unable to lengthen table"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = rows; } if (columnValues[col].skip == 0) { if (columnValues[col].type == SDDS_STRING) { SetColumnData(columnValues[col].type, &SDDS_dataset, columnValues[col].stringValues, rows, col); } else { SetColumnData(columnValues[col].type, &SDDS_dataset, columnValues[col].values, rows, col); } n++; } col++; row = 0; } else { if (noRowCount) { if (row == 0) { rows = 3; } else if (row == rows - 1) { rows = rows + 3; for (i=0;i<columns;i++) { if (rows > columnValues[i].elements) { if (columnValues[i].type == SDDS_STRING) { columnValues[i].stringValues = AllocateColumnStringData(columnValues[i].stringValues, rows, columnValues[i].elements); } else { columnValues[i].values = AllocateColumnData(columnValues[i].type, columnValues[i].values, rows); } } columnValues[i].elements = rows; } } } if (row == 0) for (i=0;i<columns;i++) { if (rows > columnValues[i].elements) { if (columnValues[i].type == SDDS_STRING) { columnValues[i].stringValues = AllocateColumnStringData(columnValues[i].stringValues, rows, columnValues[i].elements); } else { columnValues[i].values = AllocateColumnData(columnValues[i].type, columnValues[i].values, rows); } } columnValues[i].elements = rows; } if (noRowCount) { cp_str(&ptr2,ptr); i = 0; while (getToken(ptr2,data,10240,separator,whitespace) >= 0) i++; free(ptr2); if ((i != columns) && (parameters>0 && i==1)) { if (row > 0) { if (row > maxRows) { if (!SDDS_LengthenTable(&SDDS_dataset, row - maxRows)) { SDDS_SetError("Unable to lengthen table"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = row; } n=0; for (j=0;j<columns;j++) { if (columnValues[j].skip) continue; if (columnValues[j].type == SDDS_STRING) { SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].stringValues, row, n); } else { SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].values, row, n); } n++; } if (!SDDS_WritePage(&SDDS_dataset)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); maxRows = 10000; if (!SDDS_StartPage(&SDDS_dataset, initRows)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); row = par = col = 0; rows = -1; } readline = 0; continue; } } for (i=0;i<columns;i++) { if (getToken(ptr,data,10240,separator,whitespace) < 0) { if (!fillin) { SDDS_SetError("Invalid column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { switch (columnValues[i].type) { case SDDS_SHORT: case SDDS_LONG: case SDDS_FLOAT: case SDDS_DOUBLE: data[0]='0'; data[1]='\0'; break; case SDDS_STRING: case SDDS_CHARACTER: data[0]='\0'; break; } } } switch (columnValues[i].type) { case SDDS_SHORT: if (sscanf(data,"%hd",((short*)(columnValues[i].values)+row)) != 1) { if (recover) { abort=1; row--; } else { SDDS_SetError("Invalid short column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_LONG: if (sscanf(data,"%" SCNd32,((int32_t*)(columnValues[i].values)+row)) != 1) { if (recover) { abort=1; row--; } else { SDDS_SetError("Invalid long column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_FLOAT: ConvertDNotationToENotation(data); if (sscanf(data,"%f",((float*)(columnValues[i].values)+row)) != 1) { if (recover) { abort=1; row--; } else { SDDS_SetError("Invalid float column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_DOUBLE: ConvertDNotationToENotation(data); if (sscanf(data,"%lf",((double*)(columnValues[i].values)+row)) != 1) { if (recover) { abort=1; row--; } else { SDDS_SetError("Invalid double column element"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } break; case SDDS_STRING: SDDS_InterpretEscapes(data); columnValues[i].stringValues[row] = malloc(strlen(data) + 1); strcpy(columnValues[i].stringValues[row],data); break; case SDDS_CHARACTER: SDDS_InterpretEscapes(data); *((char*)(columnValues[i].values)+row) = data[0]; break; } if (recover && abort) { break; } } row++; if ((row == rows) && (!noRowCount)) { if (rows > maxRows) { if (!SDDS_LengthenTable(&SDDS_dataset, rows - maxRows)) { SDDS_SetError("Unable to lengthen table"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = rows; } n=0; for (i=0;i<columns;i++) { if (columnValues[i].skip) continue; if (columnValues[i].type == SDDS_STRING) { SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].stringValues, rows, n); } else { SetColumnData(columnValues[i].type, &SDDS_dataset, columnValues[i].values, rows, n); } n++; } } } } if ((par == parameters) && (((!noRowCount) && (rows != -1)) || (noRowCount)) && (((columnOrder) && (col == columns)) || ((columns > 0) && (row == rows)) || (columns == 0))) { if (!SDDS_WritePage(&SDDS_dataset)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = 10000; if (!SDDS_StartPage(&SDDS_dataset, initRows)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); row = par = col = 0; rows = -1; } ptr[0] = 0; } if (noRowCount) { if (row > 0) { if (row > maxRows) { if (!SDDS_LengthenTable(&SDDS_dataset, row - maxRows)) { SDDS_SetError("Unable to lengthen table"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = row; } n=0; for (j=0;j<columns;j++) { if (columnValues[j].skip) continue; if (columnValues[j].type == SDDS_STRING) { SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].stringValues, row, n); } else { SetColumnData(columnValues[j].type, &SDDS_dataset, columnValues[j].values, row, n); } n++; } if (!SDDS_WritePage(&SDDS_dataset)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } maxRows = 10000; } } for (i=0;i<columns;i++) { if (columnValues[i].type == SDDS_STRING) { for (j=0;j<columnValues[i].elements;j++) { free(columnValues[i].stringValues[j]); } free(columnValues[i].stringValues); } else { free(columnValues[i].values); } if (columnValues[i].name) free(columnValues[i].name); if (columnValues[i].units) free(columnValues[i].units); if (columnValues[i].description) free(columnValues[i].description); if (columnValues[i].symbol) free(columnValues[i].symbol); } for (i=0;i<parameters;i++) { free(parameterValues[i].name); if (parameterValues[i].units) free(parameterValues[i].units); if (parameterValues[i].description) free(parameterValues[i].description); if (parameterValues[i].symbol) free(parameterValues[i].symbol); } if (columnValues) free(columnValues); if (parameterValues) free(parameterValues); if (columnIndex) free(columnIndex); if (parameterIndex) free(parameterIndex); if (ptr) free(ptr); if (!SDDS_Terminate(&SDDS_dataset)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free_scanargs(&s_arg,argc); return 0; }
int main(int argc, char **argv) { SDDS_DATASET SDDSnew, SDDSold; long i, j, iArg; SCANNED_ARG *scArg; char *input, *output, *columnName; long mode, matchCode, rows, rowsMinus1, tmpfile_used; double gapAmount, *columnData, gapFactor; char *matchPattern; long matchPatternAfter = 0; double changeAmount, changeBase; long retval, newStart, rowLimit, breakNext; int32_t dataType, overlap=0; unsigned long flags, pipeFlags, changeFlags; char **stringData; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scArg, argc, argv); if (argc<2) { fprintf(stderr, "%s", USAGE); return(1); } columnData = NULL; stringData = NULL; input = output = columnName = NULL; mode = -1; pipeFlags = flags = 0; gapAmount = changeAmount = rowLimit = gapFactor = 0; matchPattern = NULL; for (iArg=1; iArg<argc; iArg++) { if (scArg[iArg].arg_type==OPTION) { switch (matchCode=match_string(scArg[iArg].list[0], option, N_OPTIONS, 0)) { case SET_GAPIN: if ((scArg[iArg].n_items-=2)<0 || !scanItemList(&flags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "amount", SDDS_DOUBLE, &gapAmount, 1, GAPIN_AMOUNT, "factor", SDDS_DOUBLE, &gapFactor, 1, GAPIN_FACTOR, NULL) || (flags&GAPIN_AMOUNT && gapAmount<=0) || (flags&GAPIN_FACTOR && gapFactor<=0)) { fprintf(stderr, "Error: invalid -gapin syntax/values\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_INCREASEOF: case SET_DECREASEOF: if (scArg[iArg].n_items!=2) { fprintf(stderr, "Error: invalid option syntax---specify column-name with -increaseof and -decreaseof\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_CHANGEOF: if ((scArg[iArg].n_items-=2)<0 || !scanItemList(&changeFlags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "amount", SDDS_DOUBLE, &changeAmount, 1, CHANGEOF_AMOUNT, "base", SDDS_DOUBLE, &changeBase, 1, CHANGEOF_BASE, NULL) || (changeFlags&CHANGEOF_AMOUNT && changeAmount<=0)) { fprintf(stderr, "Error: invalid -changeof syntax/values\n"); return(1); } columnName = scArg[iArg].list[1]; mode = matchCode; break; case SET_ROWLIMIT: if (scArg[iArg].n_items<2) { fprintf(stderr, "Error: invalid -rowlimit syntax\n"); return(1); } if (sscanf(scArg[iArg].list[1], "%ld", &rowLimit)!=1 || rowLimit<=0) { fprintf(stderr, "Error: invalid -rowlimit syntax\n"); return(1); } if (scArg[iArg].n_items>2) { scArg[iArg].n_items-=2; if (!scanItemList(&flags, scArg[iArg].list+2, &scArg[iArg].n_items, 0, "overlap", SDDS_LONG, &overlap, NULL) || overlap<0) { fprintf(stderr, "Error: invalid overlap given in -rowlimit syntax\n"); return(1); } } mode = matchCode; break; case SET_PIPE: if (!processPipeOption(scArg[iArg].list+1, scArg[iArg].n_items-1, &pipeFlags)) { fprintf(stderr, "Error: invalid -pipe syntax\n"); return(1); } break; case SET_MATCHTO: if ((scArg[iArg].n_items!=3 && scArg[iArg].n_items!=4) || strlen(columnName=scArg[iArg].list[1])==0 || strlen(matchPattern=scArg[iArg].list[2])==0) { fprintf(stderr, "Error: invalid -matchTo syntax\n"); return(1); } if (scArg[iArg].n_items==4) { if (strncmp(scArg[iArg].list[3], "after", strlen(scArg[iArg].list[3]))==0) matchPatternAfter = 1; else { fprintf(stderr, "Error: invalid -matchTo syntax\n"); return(1); } } mode = matchCode; break; default: fprintf(stderr, "Error: unknown switch: %s\n", scArg[iArg].list[0]); fprintf(stderr, "%s", USAGE); return(1); } } else { if (input==NULL) input = scArg[iArg].list[0]; else if (output==NULL) output = scArg[iArg].list[0]; else { fprintf(stderr, "Error: too many filenames given\n"); return(1); } } } processFilenames("sddsbreak", &input, &output, pipeFlags, 0, &tmpfile_used); if (mode==-1) { fprintf(stderr, "Error: no break mode specified\n"); return(1); } if (!SDDS_InitializeInput(&SDDSold, input) || !SDDS_InitializeCopy(&SDDSnew, &SDDSold, output, "w")) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } SDDSnew.layout.data_mode.no_row_counts = 0; if (!SDDS_WriteLayout(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (mode!=SET_ROWLIMIT) { if (SDDS_GetColumnInformation(&SDDSold, "type", &dataType, SDDS_BY_NAME, columnName)!=SDDS_LONG) { SDDS_SetError("problem getting type information on given column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (mode==SET_MATCHTO) { if (!(dataType==SDDS_STRING)) { fprintf(stderr, "Error: given column does not contain string data\n"); return(1); } } else if (!SDDS_NUMERIC_TYPE(dataType)) { if (!(mode==SET_CHANGEOF && !(changeFlags&CHANGEOF_AMOUNT) && !(changeFlags&CHANGEOF_BASE))) { fprintf(stderr, "Error: given column does not contain numeric data\n"); return(1); } } } while ((retval=SDDS_ReadPage(&SDDSold))>0) { if ((rows = SDDS_CountRowsOfInterest(&SDDSold))<0) { SDDS_SetError("Problem getting number of rows of tabular data"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } rowsMinus1 = rows-1; if (!SDDS_StartPage(&SDDSnew, rows) || !SDDS_CopyParameters(&SDDSnew, &SDDSold) || !SDDS_CopyArrays(&SDDSnew, &SDDSold)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (rows==0) { if (!SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } continue; } switch (mode) { case SET_GAPIN: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (!gapAmount && rows>1) { double *gap; gap = tmalloc(sizeof(*gap)*rows); for (i=1; i<rows; i++) gap[i-1] = fabs(columnData[i]-columnData[i-1]); if (!compute_average(&gapAmount, gap, rows-1)) { fprintf(stderr, "Error: unable to determine default gap amount--couldn't find median gap\n"); return(1); } gapAmount *= (gapFactor?gapFactor:2); free(gap); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && fabs(columnData[i]-columnData[i-1])<gapAmount) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_INCREASEOF: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && columnData[i]<=columnData[i-1]) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_DECREASEOF: if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows && columnData[i]>=columnData[i-1]) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } free(columnData); break; case SET_CHANGEOF: if (dataType!=SDDS_STRING) { if (!(columnData=SDDS_GetColumnInDoubles(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } } else { if (!(stringData=SDDS_GetColumn(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } } newStart = 0; if (dataType==SDDS_STRING || !changeAmount) { for (i=1; i<=rows; i++) { if (i!=rows && ((dataType==SDDS_STRING && strcmp(stringData[i], stringData[i-1])==0) || (dataType!=SDDS_STRING && columnData[i]==columnData[i-1]))) continue; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; } } else { long region, lastRegion; region = lastRegion = 0; if (!(changeFlags&CHANGEOF_BASE) && rows>=1) changeBase = columnData[0]; if (rows>1) lastRegion = (columnData[0]-changeBase)/changeAmount; #ifdef DEBUG fprintf(stderr, "change base=%e, lastRegion=%ld\n", changeBase, lastRegion); fprintf(stderr, "start value = %e\n", columnData[0]); #endif newStart = 0; for (i=1; i<=rows; i++) { if (i!=rows) region = (columnData[i]-changeBase)/changeAmount; if (i!=rows && region==lastRegion) continue; #ifdef DEBUG fprintf(stderr, "split after %e, before %e, region = %d\n", columnData[i-1], columnData[i], region); #endif if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = i; lastRegion = region; #ifdef DEBUG fprintf(stderr, "start value = %e\n", columnData[i]); #endif } } if (dataType!=SDDS_STRING) free(columnData); else SDDS_FreeStringArray(stringData, rows); break; case SET_MATCHTO: if (!(stringData=SDDS_GetColumn(&SDDSold, columnName))) { SDDS_SetError("unable to read specified column"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } newStart = 0; breakNext = 0; for (i=1; i<=rows; i++) { if (i!=rows && !breakNext) { if (wild_match(stringData[i], matchPattern)) { if (matchPatternAfter) { breakNext = 1; continue; } } else continue; } if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, newStart, i-1, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } breakNext = 0; newStart = i; } SDDS_FreeStringArray(stringData, rows); break; case SET_ROWLIMIT: for (i=0; i<rows; i+=rowLimit-overlap) { if ((j=i+rowLimit-1)>=rows) j = rows-1; if (!SDDS_SetRowFlags(&SDDSold, 0) || !SDDS_AssertRowFlags(&SDDSold, SDDS_INDEX_LIMITS, i, j, 1) || !SDDS_CopyRowsOfInterest(&SDDSnew, &SDDSold) || !SDDS_WritePage(&SDDSnew)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (j==rows-1) break; } break; default: fprintf(stderr, "Error: unknown break mode code seen---this can't happen\n"); return(1); } } if (retval==0) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (!SDDS_Terminate(&SDDSold)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); return(1); } if (tmpfile_used && !replaceFileAndBackUp(input, output)) { return(1); } return(0); }
int main(int argc, char **argv) { SCANNED_ARG *scanned; SDDS_TABLE inputPage, *copiedPage, outputPage; long copiedPages; char *inputfile, *outputfile; char **column, **excludeColumn=NULL; int32_t columns; long excludeColumns; char *indParameterName; char **copyColumn; int32_t copyColumns; long verbose; long slopeErrors; long iArg,i; double *indVar; char *indVarUnits; char **intColumn,**slopeColumn,**slopeSigmaColumn; char *Units,*slopeUnits; double *depVar; long order; double *coef,*coefsigma,*weight,*diff,chi; long iCol,iRow,iPage; long rows; double *slope, slope2, slopeAve, slopeSigma; unsigned long pipeFlags, majorOrderFlag; long tmpfile_used, noWarnings; long generateIndex; short columnMajorOrder=-1; copiedPage = NULL; slopeSigmaColumn = NULL; slopeUnits = Units = indVarUnits = NULL; rows = 0; slope = NULL; slope2 = 0; coef = coefsigma = weight = diff = slope = NULL; argc = scanargs(&scanned, argc, argv); if (argc == 1) bomb(NULL, USAGE); inputfile = outputfile = NULL; columns = excludeColumns = 0; column = excludeColumn = NULL; indParameterName = NULL; verbose = 0; slopeErrors = 0; pipeFlags = 0; tmpfile_used=0; noWarnings=0; for (iArg = 1; iArg<argc; iArg++) { if (scanned[iArg].arg_type == OPTION) { delete_chars(scanned[iArg].list[0], "_"); switch (match_string(scanned[iArg].list[0], commandline_option, COMMANDLINE_OPTIONS, UNIQUE_MATCH)) { case CLO_MAJOR_ORDER: majorOrderFlag=0; scanned[iArg].n_items--; if (scanned[iArg].n_items>0 && (!scanItemList(&majorOrderFlag, scanned[iArg].list+1, &scanned[iArg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) SDDS_Bomb("invalid -majorOrder syntax/values"); if (majorOrderFlag&SDDS_COLUMN_MAJOR_ORDER) columnMajorOrder=1; else if (majorOrderFlag&SDDS_ROW_MAJOR_ORDER) columnMajorOrder=0; break; case CLO_INDEPENDENT_PARAMETER: if (!(indParameterName = scanned[iArg].list[1])) SDDS_Bomb("no string given for option -independentVariable"); break; case CLO_COLUMNS: if (columns) SDDS_Bomb("only one -columns option may be given"); if (scanned[iArg].n_items<2) SDDS_Bomb("invalid -columns syntax"); column = tmalloc(sizeof(*column)*(columns = scanned[iArg].n_items-1)); for (i = 0; i<columns; i++) column[i] = scanned[iArg].list[i+1]; break; case CLO_EXCLUDE: if (excludeColumns) SDDS_Bomb("only one -excludecolumns option may be given"); if (scanned[iArg].n_items<2) SDDS_Bomb("invalid -excludecolumns syntax"); excludeColumn = tmalloc(sizeof(*excludeColumn)*(excludeColumns = scanned[iArg].n_items-1)); for (i = 0; i<excludeColumns; i++) excludeColumn[i] = scanned[iArg].list[i+1]; break; case CLO_VERBOSE: verbose = 1; break; case CLO_PIPE: if (!processPipeOption(scanned[iArg].list+1, scanned[iArg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case CLO_SLOPE_ERRORS: slopeErrors = 1; break; default: SDDS_Bomb("unrecognized option given"); break; } } else { if (!inputfile) inputfile = scanned[iArg].list[0]; else if (!outputfile) outputfile = scanned[iArg].list[0]; else SDDS_Bomb("too many filenames given"); } } processFilenames("sddsvslopes", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used); if (!indParameterName) SDDS_Bomb("independentVariable not given"); if (!excludeColumns) { excludeColumn = defaultExcludedColumn; excludeColumns = DEFAULT_EXCLUDED_COLUMNS; } if (verbose) fprintf(stderr,"Reading file %s.\n",inputfile); SDDS_InitializeInput(&inputPage, inputfile); copiedPages = 0; while (SDDS_ReadTable(&inputPage)>0) { if (!copiedPages) { copiedPage = (SDDS_TABLE*)malloc(sizeof(SDDS_TABLE)); rows = SDDS_CountRowsOfInterest(&inputPage); } else { copiedPage = (SDDS_TABLE*)realloc(copiedPage, (copiedPages+1)*sizeof(SDDS_TABLE)); } if (!SDDS_InitializeCopy(&copiedPage[copiedPages], &inputPage, NULL, "m")) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); if (!SDDS_CopyTable(&copiedPage[copiedPages], &inputPage)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); copiedPages++; } if (copiedPages<2) { fprintf(stderr,"Insufficient data (i.e. number of data pages) to fit a straight line.\n"); exit(1); } switch(SDDS_CheckColumn(&inputPage, "Rootname", NULL, SDDS_STRING, NULL)) { case SDDS_CHECK_WRONGUNITS: case SDDS_CHECK_OKAY: break; default: fprintf(stderr,"Something wrong with column %s.\n", "Rootname"); exit(1); } switch(SDDS_CheckColumn(&inputPage, "Index", NULL, SDDS_LONG, NULL)) { case SDDS_CHECK_WRONGUNITS: case SDDS_CHECK_OKAY: generateIndex = 0; break; case SDDS_CHECK_NONEXISTENT: generateIndex = 1; break; default: fprintf(stderr,"Something wrong with column %s.\n", "Rootname"); exit(1); } /****************\ * make array of independent variable \**************/ indVar = (double*)malloc(sizeof(*indVar)*copiedPages); switch(SDDS_CheckParameter(&inputPage, indParameterName, NULL, SDDS_DOUBLE, NULL)) { case SDDS_CHECK_WRONGUNITS: case SDDS_CHECK_OKAY: break; default: fprintf(stderr,"Something wrong with parameter %s.\n", indParameterName); exit(1); } for (iPage = 0; iPage<copiedPages; iPage++) { if (!SDDS_GetParameter(&copiedPage[iPage],indParameterName,&indVar[iPage])) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } if (!SDDS_GetParameterInformation(&inputPage, "units", &indVarUnits, SDDS_GET_BY_NAME, indParameterName)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!indVarUnits) { indVarUnits = (char *) malloc(sizeof(*indVarUnits)); indVarUnits[0] = 0; } /************************************\ * get columns of interest. use set_multicolumn_flags to simply * return new values for array column. \*************************************/ if (!set_multicolumn_flags(&inputPage, &column, &columns, excludeColumn, excludeColumns)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); exit(1); } /************************************\ * make column names for the output \*************************************/ intColumn = (char**)malloc((sizeof(char*)*columns)); slopeColumn = (char**)malloc((sizeof(char*)*columns)); if (slopeErrors) slopeSigmaColumn = (char**)malloc((sizeof(char*)*columns)); for (i=0; i<columns; i++) { intColumn[i] = (char*)malloc((sizeof(char)*(strlen(column[i])+strlen("Intercept")+1))); strcat(strcpy(intColumn[i], column[i]), "Intercept"); slopeColumn[i] = (char*)malloc((sizeof(char)*(strlen(column[i])+strlen("Slope")+1))); strcat(strcpy(slopeColumn[i], column[i]), "Slope"); if (slopeErrors) { slopeSigmaColumn[i] = (char*)malloc((sizeof(char)*(strlen(column[i])+strlen("SlopeSigma")+1))); strcat(strcpy(slopeSigmaColumn[i], column[i]), "SlopeSigma"); } } /************************************\ * Write layout for output file \*************************************/ if (verbose) fprintf(stderr,"Opening file %s.\n",outputfile); if(!SDDS_InitializeOutput(&outputPage,SDDS_BINARY,1, "lsf of sddsvexperiment",NULL,outputfile) || 0>SDDS_DefineParameter(&outputPage, "InputFile", "InputFile", NULL, "InputFile", NULL, SDDS_STRING, 0) || 0>SDDS_DefineParameter(&outputPage, "IndependentVariable", "IndependentVariable", NULL, "IndependentVariable", NULL, SDDS_STRING, 0) || (0>SDDS_DefineColumn(&outputPage,"Index",NULL,NULL,"Rootname index",NULL,SDDS_LONG,0))|| (0>SDDS_DefineColumn(&outputPage,"Rootname",NULL,NULL,NULL,NULL,SDDS_STRING,0))) SDDS_PrintErrors(stderr,SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (columnMajorOrder!=-1) outputPage.layout.data_mode.column_major = columnMajorOrder; else outputPage.layout.data_mode.column_major = inputPage.layout.data_mode.column_major; for (iCol=0; iCol<columns; iCol++) { if (!SDDS_GetColumnInformation(&inputPage, "units", &Units, SDDS_GET_BY_NAME,column[iCol])) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!Units) { Units = (char*) malloc(sizeof(*Units)); Units[0] = 0; } if (0>SDDS_DefineColumn(&outputPage, intColumn[iCol], NULL, Units, NULL, NULL, SDDS_DOUBLE,0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /* units for slopes columns */ if (strlen(indVarUnits) && strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)*(strlen(Units)+strlen(indVarUnits)+2)); strcat( strcat( strcpy(slopeUnits, Units), "/"), indVarUnits); } if (strlen(indVarUnits) && !strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)*(strlen(indVarUnits)+2)); strcat( strcpy( slopeUnits, "1/"), indVarUnits); } if (!strlen(indVarUnits) && strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)*(strlen(Units)+2)); strcpy( slopeUnits, indVarUnits); } if (!strlen(indVarUnits) && !strlen(Units) ) { slopeUnits = (char*)malloc(sizeof(*slopeUnits)); strcpy( slopeUnits, ""); } if (0>SDDS_DefineColumn(&outputPage, slopeColumn[iCol], NULL, slopeUnits, NULL, NULL, SDDS_DOUBLE,0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (slopeErrors) { if (0>SDDS_DefineColumn(&outputPage, slopeSigmaColumn[iCol], NULL, slopeUnits, NULL, NULL, SDDS_DOUBLE,0)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } free(slopeUnits); } if(!SDDS_WriteLayout(&outputPage) || !SDDS_StartTable(&outputPage,rows) || !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "InputFile",inputfile?inputfile:"pipe",NULL) || !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, 0, "IndependentVariable", indParameterName, NULL) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /************************************\ * Copy columns to output file (usually columns Index and Rootname) \*************************************/ copyColumns = DEFAULT_COPY_COLUMNS; copyColumn = defaultCopyColumn; if (!set_multicolumn_flags(&inputPage, ©Column, ©Columns, NULL, 0)) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); exit(1); } if(!SDDS_CopyColumns(&outputPage, &inputPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); depVar = (double*)malloc(sizeof(*depVar)*copiedPages); weight = (double*)malloc(sizeof(*weight)*copiedPages); diff = (double*)malloc(sizeof(*weight)*copiedPages); order=1; coef = (double*)malloc(sizeof(*coef)*(order+1)); coefsigma = (double*)malloc(sizeof(*coefsigma)*(order+1)); if(slopeErrors) slope = (double*)malloc(sizeof(*slope)*copiedPages); for (iCol=0; iCol<columns; iCol++) { for (iPage=0; iPage<copiedPages; iPage++) weight[iPage]=1; if (verbose) fprintf(stderr,"Doing column %s.\n", column[iCol]); for (iRow=0; iRow<rows; iRow++) { for (iPage=0; iPage<copiedPages; iPage++) { if (!SDDS_GetValue(&copiedPage[iPage], column[iCol], iRow, &depVar[iPage])) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } if (!(lsfn(indVar, depVar, weight, copiedPages, order, coef, coefsigma, &chi, diff))){ fprintf(stderr,"Problem with call to lsfn\n."); exit(1); } if (generateIndex) { if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, iRow, "Index",iRow, intColumn[iCol], coef[0], slopeColumn[iCol], coef[1], NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, iRow, intColumn[iCol], coef[0], slopeColumn[iCol], coef[1], NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if(slopeErrors){ /* recalculate the slope with a subset of points */ slopeAve= slope2 = 0; for (iPage=0; iPage<copiedPages; iPage++) { weight[iPage] = 1e10; if(iPage) weight[iPage-1] = 1; if (!(lsfn(indVar, depVar, weight, copiedPages, order, coef, coefsigma, &chi, diff))){ fprintf(stderr,"Problem with call to lsfn\n."); exit(1); } slope[iPage] = coef[1]; slopeAve += slope[iPage]; slope2 += sqr(slope[iPage]); } slopeSigma = sqrt(slope2/copiedPages - sqr(slopeAve/copiedPages)); if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, iRow, slopeSigmaColumn[iCol], slopeSigma, NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } } if( !SDDS_WriteTable(&outputPage)|| SDDS_Terminate(&inputPage) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for (iPage=0; iPage<copiedPages; iPage++) { if( !SDDS_Terminate(&copiedPage[iPage]) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if( SDDS_Terminate(&outputPage) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile)) exit(1); SDDS_FreeStringArray(column, columns); free(column); SDDS_FreeStringArray(intColumn, columns); SDDS_FreeStringArray(slopeColumn, columns); free(intColumn); free(slopeColumn); if (slopeErrors) { SDDS_FreeStringArray(slopeSigmaColumn, columns); free(slopeSigmaColumn); } free(copiedPage); free(indVar); free(depVar); if (weight) free(weight); if (diff) free(diff); if (slope) free(slope); if (coef) free(coef); if (coefsigma) free(coefsigma); if (Units) free(Units); if (indVarUnits) free(indVarUnits); free_scanargs(&scanned, argc); return(0); }
int main(int argc, char **argv) { SCANNED_ARG *s_arg; SDDS_DATASET inputPage, outputPage; char *inputfile, *outputfile; char **inputColumnName, **inputStringColumnName, **inputDoubleColumnName; char **outputStringColumnName, **outputDoubleColumnName, **matchColumn=NULL; long inputRows, inputDoubleColumns, inputStringColumns, indexColumn=0, matchColumns=0, noOldColumnNamesColumn=0; long outputRows, outputDoubleColumns, outputStringColumns; char **inputParameterName; int32_t inputParameters, inputColumns; char *inputDescription, *inputContents; char *outputDescription; long i, i_arg, col; char *buffer; char **columnOfStrings; long buffer_size; #define BUFFER_SIZE_INCREMENT 16384 MATRIX *R, *RInv; long OldStringColumnsDefined; char *inputStringRows, *outputStringRows; char **stringArray, *stringParameter; long token_length; long verbose; char format[32]; long digits; char *Symbol, *Root; void *parameterPointer; long ascii; unsigned long pipeFlags, majorOrderFlag; long tmpfile_used, noWarnings; long ipage=0, columnType; char *oldColumnNames, *newColumnNamesColumn; short columnMajorOrder=-1; inputColumnName = outputStringColumnName = outputDoubleColumnName = inputParameterName = NULL; outputRows = outputDoubleColumns = outputStringColumns = OldStringColumnsDefined = 0; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&s_arg, argc, argv); if (argc==1) bomb(NULL, USAGE); inputfile = outputfile = NULL; verbose = 0; Symbol = Root = NULL; ascii = 0; digits=3; pipeFlags = 0; tmpfile_used = 0; noWarnings = 0; oldColumnNames = NULL; newColumnNamesColumn = NULL; for (i_arg=1; i_arg<argc; i_arg++) { if (s_arg[i_arg].arg_type==OPTION) { switch(match_string(s_arg[i_arg].list[0], commandline_option, COMMANDLINE_OPTIONS, UNIQUE_MATCH)) { case CLO_MAJOR_ORDER: majorOrderFlag=0; s_arg[i_arg].n_items--; if (s_arg[i_arg].n_items>0 && (!scanItemList(&majorOrderFlag, s_arg[i_arg].list+1, &s_arg[i_arg].n_items, 0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER, "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) SDDS_Bomb("invalid -majorOrder syntax/values"); if (majorOrderFlag&SDDS_COLUMN_MAJOR_ORDER) columnMajorOrder=1; else if (majorOrderFlag&SDDS_ROW_MAJOR_ORDER) columnMajorOrder=0; break; case CLO_MATCH_COLUMN: matchColumns = s_arg[i_arg].n_items-1; matchColumn = s_arg[i_arg].list+1; break; case CLO_INDEX_COLUMN: indexColumn = 1; break; case CLO_NO_OLDCOLUMNNAMES: noOldColumnNamesColumn = 1; break; case CLO_VERBOSE: verbose=1; break; case CLO_ASCII: ascii=1; break; case CLO_DIGITS: if (!(get_long(&digits, s_arg[i_arg].list[1]))) bomb("no string given for option -digits", USAGE); break; case CLO_COLUMNROOT: if (!(Root=s_arg[i_arg].list[1])) SDDS_Bomb("No root string given"); break; case CLO_SYMBOL: if (!(Symbol=s_arg[i_arg].list[1])) SDDS_Bomb("No symbol string given"); break; case CLO_PIPE: if (!processPipeOption(s_arg[i_arg].list+1, s_arg[i_arg].n_items-1, &pipeFlags)) SDDS_Bomb("invalid -pipe syntax"); break; case CLO_OLDCOLUMNNAMES: if (!(oldColumnNames=s_arg[i_arg].list[1])) SDDS_Bomb("No oldColumnNames string given"); break; case CLO_NEWCOLUMNNAMES: if (s_arg[i_arg].n_items!=2 || SDDS_StringIsBlank(newColumnNamesColumn = s_arg[i_arg].list[1])) SDDS_Bomb("Invalid -newColumnNames syntax/value"); break; default: bomb("unrecognized option given", USAGE); } } else { if (!inputfile) inputfile = s_arg[i_arg].list[0]; else if (!outputfile) outputfile = s_arg[i_arg].list[0]; else bomb("too many filenames given", USAGE); } } processFilenames("sddstranpose", &inputfile, &outputfile, pipeFlags, noWarnings, &tmpfile_used); if (newColumnNamesColumn && Root) SDDS_Bomb("-root and -newColumnNames are incompatible"); if (!SDDS_InitializeInput(&inputPage, inputfile) || !(inputParameterName=(char**)SDDS_GetParameterNames(&inputPage, &inputParameters)) || !SDDS_GetDescription(&inputPage, &inputDescription, &inputContents)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); if (matchColumns) inputColumnName = getMatchingSDDSNames(&inputPage, matchColumn, matchColumns, &inputColumns, SDDS_MATCH_COLUMN); else { if (!(inputColumnName=(char**)SDDS_GetColumnNames(&inputPage, &inputColumns))) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); } inputDoubleColumns=0; inputStringColumns=0; inputDoubleColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputStringColumnName=(char**)malloc(inputColumns*sizeof(char*)); inputRows = 0; /*********** \ * read data * \***********/ while (0<SDDS_ReadTable(&inputPage)) { ipage ++; #if defined(DEBUG) fprintf(stderr, "working on page %ld\n", ipage); #endif if (ipage==1) { SDDS_DeferSavingLayout(1); if( !SDDS_SetColumnFlags(&inputPage, 0)) SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors); /* count the string and numerical columns in the input file */ for (i=0;i<inputColumns;i++) { if ( SDDS_NUMERIC_TYPE( columnType = SDDS_GetColumnType( &inputPage, i))) { inputDoubleColumnName[inputDoubleColumns]=inputColumnName[i]; inputDoubleColumns++; } } for (i=0; i<inputPage.layout.n_columns; i++) { if (inputPage.layout.column_definition[i].type == SDDS_STRING ) { inputStringColumnName[inputStringColumns] = inputPage.layout.column_definition[i].name; inputStringColumns++; } } if( !(inputRows=SDDS_CountRowsOfInterest(&inputPage))) SDDS_Bomb("No rows in dataset."); } else { /* these statements are executed on the subsequent pages */ if (inputRows != SDDS_CountRowsOfInterest(&inputPage)) { SDDS_Bomb("Datasets don't have the same number of rows.\nProcessing stopped before reaching the end of the input file."); } } #if defined(DEBUG) fprintf(stderr, "row flags set\n"); #endif if (inputDoubleColumns == 0) SDDS_Bomb("No numerical columns in file."); if ((ipage==1) && verbose) { fprintf(stderr, "No. of double/float/integer columns: %ld.\n", inputDoubleColumns); fprintf(stderr, "No. of string columns: %ld.\n", inputStringColumns); fprintf(stderr, "No. of rows: %ld.\n", inputRows); } /****************\ * transpose data * \****************/ if (inputDoubleColumns) { if (ipage == 1) { m_alloc(&RInv, inputRows, inputDoubleColumns); m_alloc(&R, inputDoubleColumns, inputRows); } for (col=0;col<inputDoubleColumns;col++){ if (!(R->a[col]=(double*)SDDS_GetColumnInDoubles(&inputPage, inputDoubleColumnName[col]))) { SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (verbose) { m_show(R, "%9.6le ", "Transpose of input matrix:\n", stdout); } m_trans(RInv, R); } /***************************\ * determine existence of * * transposed string columns * \***************************/ if (ipage == 1) { OldStringColumnsDefined=0; switch(SDDS_CheckParameter(&inputPage, OLD_STRING_COLUMN_NAMES, NULL, SDDS_STRING, NULL)){ case SDDS_CHECK_OKAY: OldStringColumnsDefined=1; break; case SDDS_CHECK_NONEXISTENT: break; case SDDS_CHECK_WRONGTYPE: case SDDS_CHECK_WRONGUNITS: fprintf(stderr, "Something wrong with parameter OldStringColumns.\n"); exit(1); break; } if (OldStringColumnsDefined){ /* decompose OldStringColumns into names of string columns for the output file */ if (!SDDS_GetParameter(&inputPage, OLD_STRING_COLUMN_NAMES, &inputStringRows)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Parameter OldStringColumns: %s.\n", inputStringRows); } outputStringColumnName=(char**)malloc(sizeof(char*)); outputStringColumns=0; buffer_size=BUFFER_SIZE_INCREMENT; buffer=(char*)malloc(sizeof(char)*buffer_size); while ( 0 <= (token_length = SDDS_GetToken(inputStringRows, buffer, BUFFER_SIZE_INCREMENT))){ if (!token_length) SDDS_Bomb("A null string was detected in parameter OldStringColumns.\n"); if (!SDDS_CopyString(&outputStringColumnName[outputStringColumns], buffer)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbose) { fprintf(stderr, "Output string column: %s\n", outputStringColumnName[outputStringColumns]); } outputStringColumns++; } } } /*********************\ * define output page * \*********************/ if ( ipage == 1 ) { outputRows = inputDoubleColumns; outputDoubleColumns = inputRows; if (inputDescription){ outputDescription = (char*) malloc( sizeof(char) * (strlen("Transpose of ") + strlen(inputDescription) + 1)); strcat(strcpy(outputDescription, "Transpose of "), inputDescription); if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, outputDescription, inputContents, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (!SDDS_InitializeOutput(&outputPage, ascii?SDDS_ASCII:SDDS_BINARY, 1, NULL, NULL, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (columnMajorOrder!=-1) outputPage.layout.data_mode.column_major = columnMajorOrder; else outputPage.layout.data_mode.column_major = inputPage.layout.data_mode.column_major; /***********************************\ * define names for double columns * \***********************************/ if (!Root && inputStringColumns ) { /* use specified string column, or first string column encountered */ if (!newColumnNamesColumn) /* first string column encountered */ outputDoubleColumnName = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[0]); else { /* use specified string column */ if (SDDS_CheckColumn(&inputPage, newColumnNamesColumn, NULL, SDDS_STRING, stderr)!=SDDS_CHECK_OKAY) SDDS_Bomb("column named with -newColumnNames does not exist in input"); outputDoubleColumnName = (char**)SDDS_GetColumn(&inputPage, newColumnNamesColumn); } for (i=1; i<inputRows; i++) { if (match_string(outputDoubleColumnName[i-1], outputDoubleColumnName+i, inputRows-i, EXACT_MATCH)>=0) { fprintf(stderr, "Error, duplicate %s found in input file string column %s, can not be used as output column names\n", outputDoubleColumnName[i-1], newColumnNamesColumn ? newColumnNamesColumn : inputStringColumnName[0]); exit(1); } } } else { /* use command line options to produce column names in the output file */ outputDoubleColumnName = (char**) malloc( outputDoubleColumns * sizeof(char*) ); digits = MAX(digits, log10(inputRows) + 1); if (!Root){ Root = (char*) malloc( sizeof(char) * (strlen("Column")+1) ); strcpy(Root, "Column"); } if (outputDoubleColumns!=1) { for ( i=0; i < outputDoubleColumns; i++){ outputDoubleColumnName[i] = (char*) malloc( sizeof(char) * (strlen(Root)+digits+1)); sprintf(format, "%s%%0%ldld", Root, digits); sprintf(outputDoubleColumnName[i], format, i); } } else {/* only one row to transpose */ outputDoubleColumnName[0] = (char*) malloc( sizeof(char) * (strlen(Root)+1)); strcpy( outputDoubleColumnName[0], Root); } } /*************************\ * define string columns * \*************************/ if (OldStringColumnsDefined) { if (!SDDS_DefineSimpleColumns(&outputPage, outputStringColumns, outputStringColumnName, NULL, SDDS_STRING)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { /* by default there should be at least one string column, that of the old column names. */ if (!noOldColumnNamesColumn) { outputStringColumns = 1; outputStringColumnName = (char**) malloc( sizeof(char*)); if (oldColumnNames) { /* commanline option specification */ outputStringColumnName[0] = oldColumnNames; } else { outputStringColumnName[0] = (char*) malloc( sizeof(char) * (strlen("OldColumnNames") + 1)); strcpy(outputStringColumnName[0], "OldColumnNames"); } if ( 0 > SDDS_DefineColumn(&outputPage, outputStringColumnName[0], NULL, NULL, NULL, NULL, SDDS_STRING, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } if (indexColumn && !SDDS_DefineSimpleColumn(&outputPage, "Index", NULL, SDDS_LONG)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /*************************\ * define double columns * \*************************/ for ( i=0; i < outputDoubleColumns; i++) if (Symbol){ if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], Symbol, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else { if (0>SDDS_DefineColumn(&outputPage, outputDoubleColumnName[i], NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /********************************\ * define string parameters * * i.e. transposed string columns * \********************************/ if ( inputStringColumns>1 ) { if (0>SDDS_DefineParameter(&outputPage, OLD_STRING_COLUMN_NAMES, NULL, NULL, "Transposed string columns", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); for ( i=0; i < inputStringColumns; i++){ if (0>SDDS_DefineParameter(&outputPage, inputStringColumnName[i], NULL, NULL, "Transposed string column data", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /*************************\ * transfer parameters not * * associated with old * * string columns * \*************************/ if (inputParameters) { for ( i=0; i < inputParameters; i++) { if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) if ( 0 > SDDS_TransferParameterDefinition(&outputPage, &inputPage, inputParameterName[i], NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } /***************\ * write layout * \***************/ SDDS_DeferSavingLayout(0); /* if InputFile is not already transfered ot the output file, then create it. */ switch( SDDS_CheckParameter(&outputPage, "InputFile", NULL, SDDS_STRING, NULL) ) { case SDDS_CHECK_NONEXISTENT: if (0>SDDS_DefineParameter(&outputPage, "InputFile", NULL, NULL, "Original matrix file", NULL, SDDS_STRING, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); break; default: break; } if (!SDDS_WriteLayout(&outputPage) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "table layout defined\n"); #endif if (!SDDS_StartTable(&outputPage, outputRows) ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (ipage == 1) { if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "InputFile", inputfile?inputfile:"pipe", NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } /***************************************\ * assign string columns from input * * to string parameters in output * \**************************************/ if ( inputStringColumns > 1) { for ( i=0; i < inputStringColumns; i++){ columnOfStrings = (char**) SDDS_GetColumn(&inputPage, inputStringColumnName[i]); stringParameter = JoinStrings(columnOfStrings, inputRows, BUFFER_SIZE_INCREMENT); if ( !SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, inputStringColumnName[i], stringParameter, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(columnOfStrings); free(stringParameter); } outputStringRows = JoinStrings(inputStringColumnName, inputStringColumns, BUFFER_SIZE_INCREMENT); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, OLD_STRING_COLUMN_NAMES, outputStringRows, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string parameters assigned\n"); #endif if (inputParameters){ for ( i=0; i < inputParameters; i++){ if ( (0 > match_string(inputParameterName[i], outputStringColumnName, outputStringColumns, 0) && strcasecmp(inputParameterName[i], OLD_STRING_COLUMN_NAMES))) { parameterPointer = (void*) SDDS_GetParameter(&inputPage, inputParameterName[i], NULL); if (!SDDS_SetParameters(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputParameterName[i], parameterPointer, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); free(parameterPointer); } } } #if defined(DEBUG) fprintf(stderr, "input parameters assigned\n"); #endif /**********************************\ * assign data to * * output table part of data set * \**********************************/ if (outputRows) { /***************************\ * assign string column data * \***************************/ if (OldStringColumnsDefined){ for ( i=0 ; i < outputStringColumns; i++){ if (!SDDS_GetParameter(&inputPage, outputStringColumnName[i], &stringParameter)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); stringArray=TokenizeString(stringParameter, outputRows); if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, stringArray, outputRows, outputStringColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } } else { if (!noOldColumnNamesColumn && !SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, inputDoubleColumnName, outputRows, outputStringColumnName[0])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "string data columns assigned\n"); #endif /***************************\ * assign double column data * \***************************/ for ( i=0 ; i < outputDoubleColumns; i++) /* i is the row index */ if (!SDDS_SetColumn(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_REFERENCE, RInv->a[i], outputRows, outputDoubleColumnName[i])) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (indexColumn) { for (i=0; i<outputRows; i++) if (!SDDS_SetRowValues(&outputPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, i, "Index", i, NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } #if defined(DEBUG) fprintf(stderr, "double data columns assigned\n"); #endif } #if defined(DEBUG) fprintf(stderr, "data assigned\n"); #endif if (!SDDS_WriteTable(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); #if defined(DEBUG) fprintf(stderr, "data written out\n"); #endif } if (inputDoubleColumns) { m_free(&RInv); m_free(&R); } if (inputColumnName) { SDDS_FreeStringArray(inputColumnName, inputColumns); free(inputColumnName); } if (inputStringColumns) free(inputStringColumnName); if (inputDescription) free(inputDescription); if (inputParameterName) { SDDS_FreeStringArray(inputParameterName, inputParameters); free(inputParameterName); } if (outputDoubleColumns) { SDDS_FreeStringArray(outputDoubleColumnName, outputDoubleColumns); free(outputDoubleColumnName); } if (!SDDS_Terminate(&inputPage) || !SDDS_Terminate(&outputPage)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (tmpfile_used && !replaceFileAndBackUp(inputfile, outputfile)) exit(1); return(0); }
void SetupOutputFile(char *outputfile, SDDS_DATASET *SDDSout, int mode, SDDS_DATASET *SDDSin, long copyCols, char **copyCol, long copyPars, char **copyPar) { long i, cols=0, pars=0; char **column=NULL, **par=NULL; if (!SDDS_InitializeOutput(SDDSout, SDDS_BINARY, 1, NULL, NULL, outputfile)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (copyCols) { column = getMatchingSDDSNames(SDDSin, copyCol, copyCols, &cols, SDDS_MATCH_COLUMN); SDDS_SetColumnFlags(SDDSin, 0); for (i=0; i<cols; i++) { if (!SDDS_TransferColumnDefinition(SDDSout, SDDSin, column[i], NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_SetColumnsOfInterest(SDDSin, SDDS_MATCH_STRING, column[i], SDDS_OR)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } SDDS_FreeStringArray(column, cols); } if (copyPars) { par = getMatchingSDDSNames(SDDSin, copyPar, copyPars, &pars, SDDS_MATCH_PARAMETER); for (i=0; i<pars; i++) { if (!SDDS_TransferParameterDefinition(SDDSout, SDDSin, par[i], NULL)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } SDDS_FreeStringArray(par, pars); } if (verbose > 1 ) { fprintf(stdout, "cols %ld pars %ld\n", cols, pars); } if (!SDDS_DefineSimpleParameter(SDDSout, "sddsxra_mode", NULL, SDDS_LONG) || !SDDS_DefineSimpleParameter(SDDSout, "TargetMaterial", NULL, SDDS_STRING) || !SDDS_DefineSimpleParameter(SDDSout, "TargetFormula", NULL, SDDS_STRING) || !SDDS_DefineSimpleParameter(SDDSout, "MassThickness", "g/cm^2", SDDS_DOUBLE) || !SDDS_DefineSimpleParameter(SDDSout, "TargetThickness", "mm", SDDS_DOUBLE) || !SDDS_DefineSimpleParameter(SDDSout, "TargetDensity", "g/cm^3", SDDS_DOUBLE) || !SDDS_DefineSimpleParameter(SDDSout, "ThetaIn", "degrees", SDDS_DOUBLE) || !SDDS_DefineSimpleColumn(SDDSout, "PhotonEnergy", "eV", SDDS_DOUBLE)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (mode!=1 && mode!=6 && mode!=11) { if (SDDS_DefineColumn(SDDSout, "TotalCS", NULL, "cm^2/g", "Total x-ray cross section",NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "PhotoCS", NULL, "cm^2/g", "Photoelectric cross section",NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "CoherentCS", NULL, "cm^2/g", "Coherent scattering cross section ",NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "IncoherentCS", NULL, "cm^2/g", "Incoherent scattering cross section ",NULL, SDDS_DOUBLE, 0)<0) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (mode==1 || mode==6) { if (SDDS_DefineColumn(SDDSout, "RefracIndex_Re", NULL, NULL, "Real part of refractive index", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "RefracIndex_Im", NULL, NULL, "Imaginary part of refractive index", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "delta", NULL, NULL, "Real part of 1 - n", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "beta", NULL, NULL, "Imaginary part 1 - n", NULL, SDDS_DOUBLE, 0)<0) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } else if (mode==11) { if (SDDS_DefineColumn(SDDSout, "F1", NULL, NULL, "Atomic scattering factor f1", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "F2", NULL, NULL, "Atomic scattering factor f2", NULL, SDDS_DOUBLE, 0)<0) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (mode==6) { if (SDDS_DefineColumn(SDDSout, "Reflectivity", NULL, "g/cm^3", NULL, NULL, SDDS_DOUBLE, 0)<0 || !SDDS_DefineSimpleParameter(SDDSout, "Polarization", NULL, SDDS_DOUBLE)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (mode==2 || mode==4 || mode==12 || mode==14) { if (SDDS_DefineColumn(SDDSout, "Transmission", NULL, NULL, "Ratio of x-ray beam transmitted through the film target", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "Absorption", NULL, NULL, "Ratio of x-ray beam absorbed by the film target", NULL, SDDS_DOUBLE, 0)<0 ) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (mode==4 || mode==14 ) { if (SDDS_DefineColumn(SDDSout, "TotalElectronYieldFront", NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "TotalElectronYieldBack", NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(SDDSout, "TotalElectronYield", NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0)<0 || !SDDS_DefineSimpleParameter(SDDSout, "TargetEfficiency", "g/cm^2", SDDS_DOUBLE)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (mode==20) { if (!SDDS_DefineSimpleParameter(SDDSout, "ShellID", NULL, SDDS_LONG) || !SDDS_DefineSimpleParameter(SDDSout, "ShellName", NULL, SDDS_STRING) || !SDDS_DefineSimpleParameter(SDDSout, "EdgeEnergy", "eV", SDDS_DOUBLE) || !SDDS_DefineSimpleParameter(SDDSout, "FluorYield", NULL, SDDS_DOUBLE) || !SDDS_DefineSimpleParameter(SDDSout, "JumpFactor", NULL, SDDS_DOUBLE) || !SDDS_DefineSimpleParameter(SDDSout, "LevelWidth", "eV", SDDS_DOUBLE) || !SDDS_DefineSimpleParameter(SDDSout, "ElectronConfig", "e", SDDS_DOUBLE)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_WriteLayout(SDDSout)) SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); }
void run_rpn_load(NAMELIST_TEXT *nltext, RUN *run) { SDDS_DATASET SDDSin; long code, foundPage, iColumn, matchRow, rows, iParameter; int32_t columns, parameters; char *parameterValue = NULL; double *data, data1; char **columnName, **matchColumnData, *memName = NULL; char **parameterName; /* process the namelist text */ set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS); set_print_namelist_flags(0); if (processNamelist(&rpn_load, nltext)==NAMELIST_ERROR) bombElegant(NULL, NULL); if (echoNamelists) print_namelist(stdout, &rpn_load); if (match_column && strlen(match_column)) { if (use_row!=-1) { fprintf(stdout, "Error: you asked to match a column and also gave use_row.\n"); exitElegant(1); } if (!match_column_value || !strlen(match_column_value)) { fprintf(stdout, "Error: you must give match_column_value with match_column\n"); exitElegant(1); } } if (match_parameter && strlen(match_parameter)) { if (use_page!=-1) { fprintf(stdout, "Error: you asked to match a parameter and also gave use_page.\n"); exitElegant(1); } if (!match_parameter_value || !strlen(match_parameter_value)) { fprintf(stdout, "Error: you must give match_parameter_value with match_parameter\n"); exitElegant(1); } } if (!filename || !strlen(filename)) { fprintf(stdout, "Error: no filename given for rpn_load.\n"); exitElegant(1); } filename = compose_filename(filename, run->rootname); if (!SDDS_InitializeInputFromSearchPath(&SDDSin, filename)) { fprintf(stdout, "Error: couldn't initialize SDDS input for %s\n", filename); exitElegant(1); } foundPage = 0; while ((code=SDDS_ReadPage(&SDDSin))>0) { if (use_page>0) { if (code==use_page) { foundPage = 1; break; } continue; } if (match_parameter && strlen(match_parameter)) { if (!(parameterValue=SDDS_GetParameterAsString(&SDDSin, match_parameter, NULL))) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!wild_match(parameterValue, match_parameter_value)) continue; foundPage = 1; break; } if (use_page==-1 && SDDS_CheckEndOfFile(&SDDSin)==1) { foundPage = 1; break; } } if (!foundPage) { fprintf(stdout, "Error: no appropriate page found\n"); exitElegant(1); } if (!load_parameters) { if ((columnName = SDDS_GetColumnNames(&SDDSin, &columns))==NULL) { fprintf(stdout, "Warning: No columns in file!\n"); return; } rows = SDDS_RowCount(&SDDSin); matchRow = rows-1; if (use_row!=-1) { if (use_row>=rows) { fprintf(stdout, "Error: number of rows in file (%ld) less than needed for use_row=%ld\n", rows, use_row); exitElegant(1); } matchRow = use_row; } if (match_column) { if (SDDS_GetNamedColumnType(&SDDSin, match_column)!=SDDS_STRING) { fprintf(stdout, "Error: column %s nonexistent or not string type.\n", match_column); exitElegant(1); } if (!(matchColumnData=SDDS_GetColumn(&SDDSin, match_column))) { fprintf(stdout, "Error: unable to get data for column %s\n", match_column); exitElegant(1); } if (matching_row_number<0) { /* use last match */ for (matchRow=rows-1; matchRow>=0; matchRow--) if (wild_match(matchColumnData[matchRow], match_column_value)) break; } else { /* use nth match */ for (matchRow=0; matchRow<rows; matchRow++) if (wild_match(matchColumnData[matchRow], match_column_value) && matching_row_number-- == 0) break; } if (matchRow<0 || matchRow>=rows) { fprintf(stdout, "Error: unable to find match for %s in column %s\n", match_column_value, match_column); exitElegant(1); } SDDS_FreeStringArray(matchColumnData, rows); } for (iColumn=0; iColumn<columns; iColumn++) { switch (SDDS_GetNamedColumnType(&SDDSin, columnName[iColumn])) { case SDDS_CHARACTER: case SDDS_STRING: break; default: if (!(data=SDDS_GetColumnInDoubles(&SDDSin, columnName[iColumn]))) { fprintf(stdout, "Error: unable to get data for column %s as numerical data.\n", columnName[iColumn]); exitElegant(1); } if (!(memName=SDDS_Realloc(memName, sizeof(*memName)*((tag?strlen(tag):0)+strlen(columnName[iColumn])+2)))) { fprintf(stdout, "Memory allocation failure trying to create memory name for loaded data\n"); exitElegant(1); } if (tag && strlen(tag)) sprintf(memName, "%s.%s", tag, columnName[iColumn]); else sprintf(memName, "%s", columnName[iColumn]); rpn_store(data[matchRow], NULL, rpn_create_mem(memName, 0)); fprintf(stdout, "%le --> %s\n", data[matchRow], memName); free(columnName[iColumn]); free(data); } } if (memName) free(memName); if (columnName) free(columnName); } else { /* load data from parameters */ if ((parameterName = SDDS_GetParameterNames(&SDDSin, ¶meters))==NULL) { fprintf(stdout, "Warning: No parameters in file!\n"); return; } for (iParameter=0; iParameter<parameters; iParameter++) { switch (SDDS_GetNamedParameterType(&SDDSin, parameterName[iParameter])) { case SDDS_CHARACTER: case SDDS_STRING: break; default: if (!SDDS_GetParameterAsDouble(&SDDSin, parameterName[iParameter], &data1)) { fprintf(stdout, "Error: unable to get data for parameter %s as numerical data.\n", parameterName[iParameter]); exitElegant(1); } if (!(memName=SDDS_Realloc(memName, sizeof(*memName)*((tag?strlen(tag):0)+strlen(parameterName[iParameter])+2)))) { fprintf(stdout, "Memory allocation failure trying to create memory name for loaded data\n"); exitElegant(1); } if (tag && strlen(tag)) sprintf(memName, "%s.%s", tag, parameterName[iParameter]); else sprintf(memName, "%s", parameterName[iParameter]); rpn_store(data1, NULL, rpn_create_mem(memName, 0)); fprintf(stdout, "%le --> %s\n", data1, memName); free(parameterName[iParameter]); } } if (memName) free(memName); if (parameterName) free(parameterName); } }
long expandColumnPairNames(SDDS_DATASET *SDDSin, char ***name, char ***errorName, long names, char **excludeName, long excludeNames, long typeMode, long typeValue) { long i, j, names1, errorNames1, names2; char **name1, **errorName1, **name2, **errorName2; if (!names || !*name) return 0; name2 = errorName1 = errorName2 = NULL; names2 = errorNames1 = 0; for (i=0; i<names; i++) { switch (typeMode) { case FIND_ANY_TYPE: case FIND_NUMERIC_TYPE: case FIND_INTEGER_TYPE: case FIND_FLOATING_TYPE: names1 = SDDS_MatchColumns(SDDSin, excludeNames?NULL:&name1, SDDS_MATCH_STRING, typeMode, (*name)[i], SDDS_0_PREVIOUS|SDDS_OR); break; case FIND_SPECIFIED_TYPE: if (!SDDS_VALID_TYPE(typeValue)) SDDS_Bomb("invalid type value in expandColumnPairNames"); names1 = SDDS_MatchColumns(SDDSin, excludeNames?NULL:&name1, SDDS_MATCH_STRING, typeMode, typeValue, (*name)[i], SDDS_0_PREVIOUS|SDDS_OR); break; default: SDDS_Bomb("invalid typeMode in expandColumnPairNames"); exit(1); break; } if (names1==0) continue; if (names1==-1) { SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors); SDDS_Bomb("unable to perform column name match in expandColumnPairNames"); } if (excludeNames) { for (j=0; j<excludeNames; j++) if (!(names1=SDDS_MatchColumns(SDDSin, (j==excludeNames-1?&name1:0), SDDS_MATCH_STRING, FIND_ANY_TYPE, excludeName[j], SDDS_NEGATE_MATCH|SDDS_AND))) break; } if (!names1) continue; moveToStringArray(&name2, &names2, name1, names1); if (errorName && *errorName && (*errorName)[i]) { if (strstr((*errorName)[i], "%s")) { if (!(errorName1 = (char**)malloc(sizeof(*errorName1)*names1))) SDDS_Bomb("allocation failure in expandColumnPairNames"); errorNames1 = names1; for (j=0; j<names1; j++) { if (!(errorName1[j] = (char*)malloc(sizeof(**errorName1)* strlen(name1[j])+strlen((*errorName)[i])+1))) SDDS_Bomb("allocation failure in expandColumnPairNames"); replace_stringn(errorName1[j], (*errorName)[i], "%s", name1[j], 1); if (SDDS_CheckColumn(SDDSin, errorName1[j], NULL, SDDS_ANY_NUMERIC_TYPE, stderr)!=SDDS_CHECK_OKAY) exit(1); } } else if (names1==1) { errorNames1 = 1; if (!(errorName1 = (char**)malloc(sizeof(*errorName1)))) SDDS_Bomb("allocation failure in expandColumnPairNames"); if (!SDDS_CopyString(errorName1, (*errorName)[i])) return 0; } else SDDS_Bomb("%s template must be employed with error names when primary name has wildcards"); names2 -= names1; moveToStringArray(&errorName2, &names2, errorName1, errorNames1); free(errorName1); free(name1); } } if (names2==0) return 0; SDDS_FreeStringArray(*name, names); *name = name2; if (errorName) { if (*errorName) SDDS_FreeStringArray(*errorName, names); *errorName = errorName2; } return names2; }