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);
}
int main(int argc, char **argv)
{
FILE *fileID;
SDDS_LAYOUT *layout=NULL;
SDDS_FILEBUFFER *fBuffer=NULL;
SDDS_DATASET SDDS_dataset, SDDS_dummy;
SCANNED_ARG *s_arg;
long i, j, i_arg, retval, page_number=0, size, columnOrder=0;
int32_t rows=0;
char *input, *output;
unsigned long pipeFlags=0, flags=0;
long noWarnings=0, tmpfile_used=0;
long *columnType, *columnIndex;
void **columnData;
char *buffer;
char **column, **column_match;
long columns=0, column_matches;
input = output = NULL;
columnType = columnIndex = NULL;
columnData = NULL;
column_match = NULL;
column_matches = 0;
buffer = tmalloc(sizeof(char)*16);
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_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_COLUMN:
if ((s_arg[i_arg].n_items<2))
SDDS_Bomb("invalid -column syntax");
column_matches = s_arg[i_arg].n_items - 1;
column_match = tmalloc(sizeof(*column_match)*column_matches);
for (i=0; i<column_matches; i++)
column_match[i] = s_arg[i_arg].list[i+1];
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("sdds2headlessdata", &input, &output, pipeFlags, noWarnings, &tmpfile_used);
if (!column_matches)
SDDS_Bomb("you must specify -column options");
if (!SDDS_InitializeInput(&SDDS_dataset, input)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
column = getMatchingSDDSNames(&SDDS_dataset, column_match, column_matches, &columns, SDDS_MATCH_COLUMN);
if (!columns)
SDDS_Bomb("No columns found in the input file.");
columnType = tmalloc(sizeof(*columnType)*columns);
columnIndex = tmalloc(sizeof(*columnIndex)*columns);
columnData = tmalloc(sizeof(*columnData)*columns);
for (i=0; i<columns; i++) {
if ((columnIndex[i]=SDDS_GetColumnIndex(&SDDS_dataset, column[i]))<0) {
fprintf(stderr, "error: column %s does not exist\n", column[i]);
exit(1);
}
if ((columnType[i]=SDDS_GetColumnType(&SDDS_dataset, columnIndex[i]))<=0) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
}
if (!output) {
#if defined(_WIN32)
if (_setmode(_fileno(stdout), _O_BINARY) == -1) {
fprintf(stderr, "error: unable to set stdout to binary mode\n");
exit(1);
}
#endif
fileID = stdout;
} else {
fileID = fopen(output, "wb");
}
if (fileID == NULL) {
fprintf(stderr, "unable to open output file for writing\n");
exit(1);
}
layout = &SDDS_dataset.layout;
fBuffer = &SDDS_dummy.fBuffer;
fBuffer->buffer = NULL;
if (!fBuffer->buffer) {
if (!(fBuffer->buffer = fBuffer->data = SDDS_Malloc(sizeof(char)*SDDS_FILEBUFFER_SIZE))) {
fprintf(stderr, "Unable to do buffered read--allocation failure\n");
exit(1);
}
fBuffer->bufferSize = SDDS_FILEBUFFER_SIZE;
fBuffer->bytesLeft = SDDS_FILEBUFFER_SIZE;
}
retval = -1;
while (retval!=page_number && (retval=SDDS_ReadPage(&SDDS_dataset))>0) {
if (page_number && retval!=page_number)
continue;
if ((rows=SDDS_CountRowsOfInterest(&SDDS_dataset))<0) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
if (rows) {
if (columnOrder) {
for (j=0; j<columns; j++) {
if (columnType[j]==SDDS_STRING) {
for (i=0; i<rows; i++) {
if (!SDDS_WriteBinaryString(*((char**)SDDS_dataset.data[columnIndex[j]]+i), fileID, fBuffer)) {
fprintf(stderr, "Unable to write rows--failure writing string\n");
exit(1);
}
}
} else {
size = SDDS_type_size[columnType[j]-1];
for (i=0; i<rows; i++) {
if (!SDDS_BufferedWrite((char*)SDDS_dataset.data[columnIndex[j]]+i*size, size, fileID, fBuffer)) {
fprintf(stderr, "Unable to write rows--failure writing string\n");
exit(1);
}
}
}
}
} else {
for (i=0; i<rows; i++) {
for (j=0; j<columns; j++) {
if (columnType[j]==SDDS_STRING) {
if (!SDDS_WriteBinaryString(*((char**)SDDS_dataset.data[columnIndex[j]]+i), fileID, fBuffer)) {
fprintf(stderr, "Unable to write rows--failure writing string\n");
exit(1);
}
} else {
size = SDDS_type_size[columnType[j]-1];
if (!SDDS_BufferedWrite((char*)SDDS_dataset.data[columnIndex[j]]+i*size, size, fileID, fBuffer)) {
fprintf(stderr, "Unable to write rows--failure writing string\n");
exit(1);
}
}
}
}
}
}
if (retval==0) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
}
if (!SDDS_FlushBuffer(fileID, fBuffer)) {
SDDS_SetError("Unable to write page--buffer flushing problem (SDDS_WriteBinaryPage)");
return 0;
}
fclose(fileID);
if (!SDDS_Terminate(&SDDS_dataset)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
exit(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);
}