void SetupOutputFile(SDDS_DATASET *SDDS_out, char *output, long zdim)
{
if (!SDDS_InitializeOutput(SDDS_out, SDDS_BINARY, 0, NULL, NULL, output))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!SDDS_DefineSimpleParameter(SDDS_out, "origin1", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "origin2", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "max_ext1", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "max_ext2", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "delta1", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "delta2", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "numPhysCells1", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleParameter(SDDS_out, "numPhysCells2", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleParameter(SDDS_out, "xstart", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "xend", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "ystart", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "yend", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(SDDS_out, "x", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(SDDS_out, "YAve", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(SDDS_out, "JzAve", NULL, SDDS_DOUBLE))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (zdim>1) {
if (!SDDS_DefineSimpleParameter(SDDS_out, "origin3", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "max_ext3", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "delta3", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "numPhysCells3", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleParameter(SDDS_out, "zstart", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "zend", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(SDDS_out, "ZAve", NULL, SDDS_DOUBLE))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_WriteLayout(SDDS_out))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
void SetupOutputFile(SDDS_DATASET *SDDS_out, char *output, long yz, long outputColumns, char **outputColumn)
{
long i;
if (!SDDS_InitializeOutput(SDDS_out, SDDS_BINARY, 0, NULL, NULL, output))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!SDDS_DefineSimpleParameter(SDDS_out, "origin1", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "origin2", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "origin3", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "max_ext1", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "max_ext2", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "max_ext3", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "delta1", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "delta2", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "delta3", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "numPhysCells1", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleParameter(SDDS_out, "numPhysCells2", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleParameter(SDDS_out, "numPhysCells3", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleParameter(SDDS_out, "Variable1Name", NULL, SDDS_STRING) ||
!SDDS_DefineSimpleParameter(SDDS_out, "Variable2Name", NULL, SDDS_STRING) ||
!SDDS_DefineSimpleParameter(SDDS_out, "ZMinimum", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "ZMaximum", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "ZInterval", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "ZDimension", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleColumn(SDDS_out, "z", NULL, SDDS_DOUBLE))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (yz) {
if (!SDDS_DefineSimpleParameter(SDDS_out, "YMinimum", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "YMaximum", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "YInterval", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "YDimension", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleColumn(SDDS_out, "y", NULL, SDDS_DOUBLE) )
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else {
/* xz */
if (!SDDS_DefineSimpleParameter(SDDS_out, "XMinimum", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "XMaximum", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "XInterval", NULL, SDDS_DOUBLE) ||
!SDDS_DefineSimpleParameter(SDDS_out, "XDimension", NULL, SDDS_LONG) ||
!SDDS_DefineSimpleColumn(SDDS_out, "x", NULL, SDDS_DOUBLE) )
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
for (i=0; i<outputColumns; i++) {
if (!SDDS_DefineSimpleColumn(SDDS_out, outputColumn[i], NULL, SDDS_DOUBLE))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_WriteLayout(SDDS_out))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
long setupOutputFile(SDDS_DATASET *outData, char *output, SDDS_DATASET *inData,
STAT_DEFINITION *stat, long stats)
{
long column;
char s[SDDS_MAXLINE];
if (!SDDS_InitializeCopy(outData, inData, output, "w"))
return 0;
for (column=0; column<stats; column++) {
if (!SDDS_TransferColumnDefinition(outData, inData, stat[column].sourceColumn[0],
stat[column].resultColumn)) {
sprintf(s, "Problem transferring definition of column %s to %s\n",
stat[column].sourceColumn[0], stat[column].resultColumn);
SDDS_SetError(s);
return 0;
}
if ((stat[column].resultIndex
= SDDS_GetColumnIndex(outData, stat[column].resultColumn))<0) {
sprintf(s, "Problem creating column %s", stat[column].resultColumn);
SDDS_SetError(s);
return 0;
}
if (stat[column].positionColumn) {
if (!SDDS_DefineSimpleColumn(outData, stat[column].positionColumn, NULL, SDDS_STRING)) {
sprintf(s, "Problem define column %s\n", stat[column].positionColumn);
SDDS_SetError(s);
return 0;
}
if ((stat[column].positionColumnIndex
= SDDS_GetColumnIndex(outData, stat[column].positionColumn))<0) {
sprintf(s, "Problem creating column %s", stat[column].positionColumn);
SDDS_SetError(s);
return 0;
}
}
if (!SDDS_ChangeColumnInformation
(outData, "description", "", SDDS_SET_BY_NAME, stat[column].resultColumn) ||
!SDDS_ChangeColumnInformation
(outData, "symbol", "", SDDS_SET_BY_NAME, stat[column].resultColumn) ||
!SDDS_ChangeColumnInformation
(outData, "type", "double", SDDS_SET_BY_NAME|SDDS_PASS_BY_STRING, stat[column].resultColumn)) {
sprintf(s, "Problem changing attributes of new column %s", stat[column].resultColumn);
SDDS_SetError(s);
return 0;
}
}
if (!SDDS_WriteLayout(outData))
return 0;
return 1;
}
int main(int argc, char **argv)
{
int iArg;
char *input, *output,*meanPar, *sigmaPar, *maxPar, *minPar;
long i, j, mainInputOpened, haltonID=0, requireInput=0;
unsigned long pipeFlags;
SCANNED_ARG *scanned;
SDDS_DATASET SDDSin, SDDSout, *SDDSptr;
long randomNumberSeed = 0;
SEQ_REQUEST *seqRequest;
long samples, values, seqRequests, randomizationGroups=0;
double *sample, *IVValue, *CDFValue;
char msgBuffer[1000];
RANDOMIZED_ORDER *randomizationData = NULL;
long verbose, optimalHalton=0;
SDDS_RegisterProgramName(argv[0]);
argc = scanargs(&scanned, argc, argv);
if (argc<2) {
fprintf(stderr, "%s%s%s\n", USAGE1, USAGE2, USAGE3);
return(1);
}
seqRequest = NULL;
seqRequests = 0;
output = input = NULL;
pipeFlags = 0;
samples = values = 0;
sample = IVValue = CDFValue = NULL;
verbose = 0;
maxPar = minPar = meanPar = sigmaPar = NULL;
for (iArg=1; iArg<argc; iArg++) {
if (scanned[iArg].arg_type==OPTION) {
/* process options here */
switch (match_string(scanned[iArg].list[0], option, CLO_OPTIONS, 0)) {
case CLO_COLUMNS:
if (scanned[iArg].n_items<3)
SDDS_Bomb("invalid -columns syntax");
if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest)*(seqRequests+1))))
SDDS_Bomb("memory allocation failure");
scanned[iArg].n_items -= 1;
memset(seqRequest+seqRequests, 0, sizeof(*seqRequest));
/*remove following pointer initialization because memset already initialize them */
seqRequest[seqRequests].randomizationGroup = -1;
seqRequest[seqRequests].factor = 1;
seqRequest[seqRequests].offset = 0;
if (!scanItemList(&seqRequest[seqRequests].flags,
scanned[iArg].list+1, &scanned[iArg].n_items, 0,
"datafile", SDDS_STRING,
&seqRequest[seqRequests].dataFileName, 1, SEQ_DATAFILE,
"independentvariable", SDDS_STRING,
&seqRequest[seqRequests].indepName, 1, SEQ_INDEPNAME,
"cdf", SDDS_STRING,
&seqRequest[seqRequests].CDFName, 1, SEQ_CDFNAME,
"df", SDDS_STRING,
&seqRequest[seqRequests].DFName, 1, SEQ_DFNAME,
"output", SDDS_STRING,
&seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
"units", SDDS_STRING,
&seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN,
"haltonradix", SDDS_LONG,
&seqRequest[seqRequests].haltonRadix, 1, SEQ_HALTONRADIX,
"haltonoffset", SDDS_LONG,
&seqRequest[seqRequests].haltonOffset, 1, SEQ_HALTONOFFSET,
"randomize", -1, NULL, 0, SEQ_RANDOMIZE,
"group", SDDS_LONG,
&seqRequest[seqRequests].randomizationGroup, 1, SEQ_RANDOMGROUP,
"factor", SDDS_DOUBLE,
&seqRequest[seqRequests].factor, 1, 0,
"offset", SDDS_DOUBLE,
&seqRequest[seqRequests].offset, 1, 0,
NULL) ||
bitsSet(seqRequest[seqRequests].flags&(SEQ_INDEPNAME+SEQ_CDFNAME+SEQ_DFNAME))!=2)
SDDS_Bomb("invalid -columns syntax");
if (seqRequest[seqRequests].flags&SEQ_RANDOMGROUP &&
seqRequest[seqRequests].randomizationGroup<=0)
SDDS_Bomb("use a positive integer for the randomization group ID");
if (seqRequest[seqRequests].flags&SEQ_CDFNAME &&
seqRequest[seqRequests].flags&SEQ_DFNAME)
SDDS_Bomb("give df or cdf for -columns, not both");
if (seqRequest[seqRequests].flags&SEQ_HALTONRADIX &&
!is_prime(seqRequest[seqRequests].haltonRadix))
SDDS_Bomb("halton radix must be a prime number");
seqRequests ++;
scanned[iArg].n_items += 1;
break;
case CLO_GAUSSIAN:
if (scanned[iArg].n_items<2)
SDDS_Bomb("invalid -gaussian syntax");
if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest)*(seqRequests+1))))
SDDS_Bomb("memory allocation failure");
memset(seqRequest+seqRequests, 0, sizeof(*seqRequest));
scanned[iArg].n_items -= 1;
seqRequest[seqRequests].randomizationGroup = -1;
seqRequest[seqRequests].mean = 0;
seqRequest[seqRequests].sigma = 1;
if (!scanItemList(&seqRequest[seqRequests].flags,
scanned[iArg].list+1, &scanned[iArg].n_items, 0,
"columnName", SDDS_STRING, &seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
"meanValue", SDDS_STRING, &meanPar, 1, 0,
"sigmaValue", SDDS_STRING, &sigmaPar, 1, 0,
"units", SDDS_STRING, &seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN,
NULL))
SDDS_Bomb("invalid -gaussian syntax");
seqRequest[seqRequests].flags |= SEQ_DIRECT_GAUSSIAN;
if (!(seqRequest[seqRequests].flags&SEQ_OUTPUTNAME) || !(seqRequest[seqRequests].outputName))
SDDS_Bomb("columnName is not provided for gaussian distribution/");
if (meanPar) {
if (wild_match(meanPar, "@*"))
SDDS_CopyString(&seqRequest[seqRequests].meanPar, meanPar+1);
else if (!get_double(&seqRequest[seqRequests].mean, meanPar))
SDDS_Bomb("Invalid value given for mean value of -gaussian distribution.");
free(meanPar);
meanPar = NULL;
}
if (sigmaPar) {
if (wild_match(sigmaPar, "@*"))
SDDS_CopyString(&seqRequest[seqRequests].sigmaPar, sigmaPar+1);
else if (!get_double(&seqRequest[seqRequests].sigma, sigmaPar))
SDDS_Bomb("Invalid value given for sigma value of -gaussian distribution.");
free(sigmaPar);
sigmaPar = NULL;
}
seqRequests ++;
scanned[iArg].n_items += 1;
break;
case CLO_UNIFORM:
if (scanned[iArg].n_items<2)
SDDS_Bomb("invalid -uniform syntax");
if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest)*(seqRequests+1))))
SDDS_Bomb("memory allocation failure");
memset(seqRequest+seqRequests, 0, sizeof(*seqRequest));
scanned[iArg].n_items -= 1;
memset(seqRequest+seqRequests, 0, sizeof(*seqRequest));
seqRequest[seqRequests].randomizationGroup = -1;
seqRequest[seqRequests].min = 0;
seqRequest[seqRequests].max = 1;
if (!scanItemList(&seqRequest[seqRequests].flags,
scanned[iArg].list+1, &scanned[iArg].n_items, 0,
"columnName", SDDS_STRING, &seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
"minimumValue", SDDS_STRING, &minPar, 1, 0,
"maximumValue", SDDS_STRING, &maxPar, 1, 0,
"units", SDDS_STRING, &seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN,
NULL))
SDDS_Bomb("invalid -uniform syntax");
seqRequest[seqRequests].flags |= SEQ_DIRECT_UNIFORM;
if (!(seqRequest[seqRequests].flags&SEQ_OUTPUTNAME) || !(seqRequest[seqRequests].outputName))
SDDS_Bomb("columnName is not provided for uniform distribution/");
if (minPar) {
if (wild_match(minPar, "@*"))
SDDS_CopyString(&seqRequest[seqRequests].minPar, minPar+1);
else if (!get_double(&seqRequest[seqRequests].min, minPar))
SDDS_Bomb("Invalid value given for minimum value of -uniform distribution.");
free(minPar);
minPar = NULL;
}
if (maxPar) {
if (wild_match(maxPar, "@*"))
SDDS_CopyString(&seqRequest[seqRequests].maxPar, maxPar+1);
else if (!get_double(&seqRequest[seqRequests].max, maxPar))
SDDS_Bomb("Invalid value given for maximum value of -uniform distribution.");
free(maxPar);
maxPar = NULL;
}
seqRequests ++;
scanned[iArg].n_items += 1;
break;
case CLO_POISSON:
if (scanned[iArg].n_items<2)
SDDS_Bomb("invalid -poisson syntax");
if (!(seqRequest = SDDS_Realloc(seqRequest, sizeof(*seqRequest)*(seqRequests+1))))
SDDS_Bomb("memory allocation failure");
memset(seqRequest+seqRequests, 0, sizeof(*seqRequest));
scanned[iArg].n_items -= 1;
memset(seqRequest+seqRequests, 0, sizeof(*seqRequest));
seqRequest[seqRequests].randomizationGroup = -1;
seqRequest[seqRequests].mean = 1;
if (!scanItemList(&seqRequest[seqRequests].flags,
scanned[iArg].list+1, &scanned[iArg].n_items, 0,
"columnName", SDDS_STRING, &seqRequest[seqRequests].outputName, 1, SEQ_OUTPUTNAME,
"meanValue", SDDS_STRING, &meanPar, 1, 0,
"units", SDDS_STRING, &seqRequest[seqRequests].units, 1, SEQ_UNITSGIVEN,
NULL))
SDDS_Bomb("invalid -poisson syntax");
seqRequest[seqRequests].flags |= SEQ_DIRECT_POISSON;
if (!(seqRequest[seqRequests].flags&SEQ_OUTPUTNAME) || !(seqRequest[seqRequests].outputName))
SDDS_Bomb("columnName is not provided for uniform distribution/");
if (meanPar) {
if (wild_match(meanPar, "@*"))
SDDS_CopyString(&seqRequest[seqRequests].meanPar, meanPar+1);
else if (!get_double(&seqRequest[seqRequests].mean, meanPar))
SDDS_Bomb("Invalid value given for mean value of -poisson distribution.");
free(meanPar);
meanPar = NULL;
}
seqRequests ++;
scanned[iArg].n_items += 1;
break;
case CLO_SAMPLES:
if (scanned[iArg].n_items!=2 ||
sscanf(scanned[iArg].list[1], "%ld", &samples)!=1 ||
samples<=0)
SDDS_Bomb("invalid -samples syntax");
break;
case CLO_SEED:
if (scanned[iArg].n_items!=2 ||
sscanf(scanned[iArg].list[1], "%ld", &randomNumberSeed)!=1 ||
randomNumberSeed<=0)
SDDS_Bomb("invalid -seed syntax");
break;
case CLO_PIPE:
if (!processPipeOption(scanned[iArg].list+1, scanned[iArg].n_items-1, &pipeFlags))
SDDS_Bomb("invalid -pipe syntax");
break;
case CLO_VERBOSE:
verbose = 1;
break;
case CLO_OPTIMAL_HALTON:
optimalHalton = 1;
break;
default:
fprintf(stderr, "error: unknown/ambiguous option: %s\n",
scanned[iArg].list[0]);
exit(1);
break;
}
}
else {
if (!input)
input = scanned[iArg].list[0];
else if (!output)
output = scanned[iArg].list[0];
else
SDDS_Bomb("too many filenames seen");
}
}
if (!seqRequests)
SDDS_Bomb("give one or more -columns options");
if (samples<1)
SDDS_Bomb("-samples option not given");
for (i=0; i<seqRequests; i++) {
if (!(seqRequest[i].flags&
(SEQ_DATAFILE|SEQ_DIRECT_GAUSSIAN|SEQ_DIRECT_UNIFORM|SEQ_DIRECT_POISSON)))
break;
}
if (i==seqRequests) {
/* all columns options have either their own input files or else use
* one of the "direct" distributions. Hence, we don't expect an input
* file.
*/
if (!input)
pipeFlags |= USE_STDIN; /* not really, but fakes out processFilenames */
if (input && !output) {
output = input;
input = NULL;
pipeFlags |= USE_STDIN;
if (fexists(output)) {
sprintf(msgBuffer, "%s exists already (sddssampledist)", output);
SDDS_Bomb(msgBuffer);
}
}
}
processFilenames("sddssampledist", &input, &output, pipeFlags, 0, NULL);
if (!SDDS_InitializeOutput(&SDDSout, SDDS_BINARY, 0, NULL, NULL, output))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (verbose)
fprintf(stderr, "Initialized output file %s\n", output);
/* open and check input files */
for (i=mainInputOpened=0; i<seqRequests; i++) {
if (seqRequest[i].flags&SEQ_DIRECT_GAUSSIAN) {
if (seqRequest[i].meanPar || seqRequest[i].sigmaPar) {
if (!mainInputOpened) {
if (!SDDS_InitializeInput(&SDDSin, input) ||
!SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
mainInputOpened = 1;
}
requireInput = 1;
SDDSptr = &SDDSin;
if ((seqRequest[i].meanPar &&
SDDS_CheckParameter(SDDSptr, seqRequest[i].meanPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr)!=SDDS_CHECK_OK) ||
(seqRequest[i].sigmaPar &&
SDDS_CheckParameter(SDDSptr, seqRequest[i].sigmaPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr)!=SDDS_CHECK_OK)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
}
if (!SDDS_DefineSimpleColumn(&SDDSout, seqRequest[i].outputName, NULL, SDDS_DOUBLE))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else if (seqRequest[i].flags&SEQ_DIRECT_UNIFORM) {
if (seqRequest[i].minPar || seqRequest[i].maxPar) {
if (!mainInputOpened) {
if (!SDDS_InitializeInput(&SDDSin, input) ||
!SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
mainInputOpened = 1;
}
requireInput = 1;
SDDSptr = &SDDSin;
if ((seqRequest[i].minPar &&
SDDS_CheckParameter(SDDSptr, seqRequest[i].minPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr)!=SDDS_CHECK_OK) ||
(seqRequest[i].maxPar &&
SDDS_CheckParameter(SDDSptr, seqRequest[i].maxPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr)!=SDDS_CHECK_OK)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
}
if (!SDDS_DefineSimpleColumn(&SDDSout, seqRequest[i].outputName, NULL, SDDS_DOUBLE))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else if (seqRequest[i].flags&SEQ_DIRECT_POISSON) {
if (seqRequest[i].meanPar) {
if (!mainInputOpened) {
if (!SDDS_InitializeInput(&SDDSin, input) ||
!SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
mainInputOpened = 1;
}
requireInput = 1;
SDDSptr = &SDDSin;
if ( SDDS_CheckParameter(SDDSptr, seqRequest[i].meanPar, NULL, SDDS_ANY_NUMERIC_TYPE, stderr)!=SDDS_CHECK_OK) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
}
if (!SDDS_DefineSimpleColumn(&SDDSout, seqRequest[i].outputName, NULL, SDDS_LONG))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else {
if (seqRequest[i].flags&SEQ_RANDOMIZE) {
long newGroupID=0;
/* define randomization groups */
if (seqRequest[i].flags&SEQ_RANDOMGROUP) {
newGroupID = seqRequest[i].randomizationGroup;
for (j=0; j<randomizationGroups; j++)
if (randomizationData[j].group==newGroupID) {
newGroupID = 0;
break;
}
} else {
seqRequest[i].randomizationGroup = newGroupID = -(i+1);
}
if (newGroupID!=0) {
if (!(randomizationData =
SDDS_Realloc(randomizationData,
sizeof(*randomizationData)*(randomizationGroups+1))))
SDDS_Bomb("memory allocation failure");
randomizationData[randomizationGroups].group = newGroupID;
randomizationData[randomizationGroups].order = NULL;
randomizationGroups ++;
}
}
if (seqRequest[i].flags&SEQ_DATAFILE) {
if (!SDDS_InitializeInput(&seqRequest[i].SDDSin,
seqRequest[i].dataFileName))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
SDDSptr = &seqRequest[i].SDDSin;
} else {
if (!mainInputOpened) {
if (!SDDS_InitializeInput(&SDDSin, input) ||
!SDDS_TransferAllParameterDefinitions(&SDDSout, &SDDSin, 0))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
mainInputOpened = 1;
}
requireInput = 1;
SDDSptr = &SDDSin;
}
if (SDDS_CheckColumn(SDDSptr,
seqRequest[i].indepName, NULL, SDDS_ANY_NUMERIC_TYPE,
stderr)!=SDDS_CHECK_OK ||
((seqRequest[i].flags&SEQ_CDFNAME) &&
SDDS_CheckColumn(SDDSptr, seqRequest[i].CDFName, NULL, SDDS_ANY_NUMERIC_TYPE,
stderr)!=SDDS_CHECK_OK) ||
((seqRequest[i].flags&SEQ_DFNAME) &&
SDDS_CheckColumn(SDDSptr, seqRequest[i].DFName, NULL, SDDS_ANY_NUMERIC_TYPE,
stderr)!=SDDS_CHECK_OK) ||
!SDDS_TransferColumnDefinition(&SDDSout, SDDSptr,
seqRequest[i].indepName,
seqRequest[i].outputName)) {
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exit(1);
}
}
if (seqRequest[i].flags&SEQ_UNITSGIVEN &&
!SDDS_ChangeColumnInformation(&SDDSout, "units", seqRequest[i].units,
SDDS_SET_BY_NAME,
seqRequest[i].outputName))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (verbose)
fprintf(stderr, "Initialized input files\n");
if (!SDDS_WriteLayout(&SDDSout))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (randomNumberSeed==0) {
randomNumberSeed = (long)time((time_t *) NULL);
randomNumberSeed = 2*(randomNumberSeed/2) + 1;
#if defined(_WIN32)
random_1(-labs(randomNumberSeed));
#else
random_1(-FABS(randomNumberSeed));
#endif
} else
random_1(-randomNumberSeed);
if (!((sample = calloc(sizeof(*sample), samples))))
SDDS_Bomb("memory allocation failure");
while (1) {
if (verbose)
fprintf(stderr, "Beginning page loop\n");
if (input && SDDS_ReadPage(&SDDSin)<=0)
break;
for (i=0; i<seqRequests; i++) {
if (seqRequest[i].flags&SEQ_DATAFILE &&
SDDS_ReadPage(&seqRequest[i].SDDSin)<=0)
break;
}
if (i!=seqRequests)
break;
if (!SDDS_StartPage(&SDDSout, samples) ||
(input && !SDDS_CopyParameters(&SDDSout, &SDDSin)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (verbose)
fprintf(stderr, "Defining randomization tables\n");
/* define randomization tables */
for (i=0; i<randomizationGroups; i++) {
if (!(randomizationData[i].order=
SDDS_Malloc(sizeof(*randomizationData[i].order)*samples)))
SDDS_Bomb("memory allocation failure");
for (j=0; j<samples; j++)
randomizationData[i].order[j] = j;
randomizeOrder((char*)randomizationData[i].order,
sizeof(*randomizationData[i].order), samples, 0,
random_1);
}
if (verbose)
fprintf(stderr, "Beginning loop over sequence requests\n");
for (i=0; i<seqRequests; i++) {
if (verbose)
fprintf(stderr, "Processing sequence request %ld\n", i);
if (seqRequest[i].flags&SEQ_DIRECT_GAUSSIAN) {
if ((seqRequest[i].meanPar && !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].meanPar, &seqRequest[i].mean)) ||
(seqRequest[i].sigmaPar && !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].sigmaPar, &seqRequest[i].sigma)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (j=0; j<samples; j++)
sample[j] = gauss_rn_lim(seqRequest[i].mean, seqRequest[i].sigma, -1, random_1);
} else if (seqRequest[i].flags&SEQ_DIRECT_UNIFORM) {
if ((seqRequest[i].minPar && !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].minPar, &seqRequest[i].min)) ||
(seqRequest[i].maxPar && !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].maxPar, &seqRequest[i].max)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (j=0; j<samples; j++)
sample[j] = seqRequest[i].min + (seqRequest[i].max - seqRequest[i].min) * random_1(1);
} else if (seqRequest[i].flags&SEQ_DIRECT_POISSON) {
double *pos_x, *pos_cdf, CDF;
long pos_points, code;
pos_x = pos_cdf = NULL;
if ((seqRequest[i].meanPar && !SDDS_GetParameterAsDouble(&SDDSin, seqRequest[i].meanPar, &seqRequest[i].mean)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
pos_points = CreatePoissonDistributionTable(&pos_x, &pos_cdf, seqRequest[i].mean);
for (j=0; j<samples; j++) {
CDF = random_1(1);
sample[j]= (int)(interp(pos_x, pos_cdf, pos_points, CDF, 0, 1, &code));
/* fprintf(stderr, "%d, cdf=%f, sample=%f\n", j, CDF, sample[j]);*/
}
free(pos_x);
free(pos_cdf);
} else {
if (input && !(seqRequest[i].flags&SEQ_DATAFILE))
SDDSptr = &SDDSin;
else
SDDSptr = &seqRequest[i].SDDSin;
if ((values = SDDS_CountRowsOfInterest(SDDSptr))) {
if (!(IVValue
= SDDS_GetColumnInDoubles(SDDSptr, seqRequest[i].indepName)) ||
(seqRequest[i].flags&SEQ_CDFNAME &&
!(CDFValue
= SDDS_GetColumnInDoubles(SDDSptr, seqRequest[i].CDFName))) ||
(seqRequest[i].flags&SEQ_DFNAME &&
!(CDFValue
= SDDS_GetColumnInDoubles(SDDSptr, seqRequest[i].DFName))))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else {
sprintf(msgBuffer, "empty page for file %s\n",
seqRequest[i].flags&SEQ_DATAFILE?
seqRequest[i].dataFileName:input);
SDDS_Bomb(msgBuffer);
}
if (verbose)
fprintf(stderr, "Checking and converting CDF/DF values\n");
/* check/convert CDF/DF values */
for (j=1; j<values; j++) {
if (IVValue[j-1]>IVValue[j]) {
sprintf(msgBuffer, "random variate values not monotonically increasing for %s",
seqRequest[i].flags&SEQ_DATAFILE?
seqRequest[i].dataFileName:input);
SDDS_Bomb(msgBuffer);
}
if (seqRequest[i].flags&SEQ_DFNAME)
/* convert DF to CDF */
CDFValue[j] += CDFValue[j-1];
if (CDFValue[j] < CDFValue[j-1]) {
sprintf(msgBuffer, "CDF values decreasing for %s",
seqRequest[i].flags&SEQ_DATAFILE?
seqRequest[i].dataFileName:input);
SDDS_Bomb(msgBuffer);
}
}
if (verbose)
fprintf(stderr, "Normalizing CDF\n");
/* normalize the CDF */
if (CDFValue[values-1]<=0) {
sprintf(msgBuffer, "CDF not valid for %s\n",
seqRequest[i].dataFileName);
SDDS_Bomb(msgBuffer);
}
for (j=0; j<values; j++)
CDFValue[j] /= CDFValue[values-1];
if (seqRequest[i].flags&SEQ_HALTONRADIX) {
if (verbose)
fprintf(stderr, "Starting halton sequence, offset=%" PRId32 "\n", seqRequest[i].haltonOffset);
if (!optimalHalton)
haltonID = startHaltonSequence(&seqRequest[i].haltonRadix, 0.5);
else
haltonID = startModHaltonSequence(&seqRequest[i].haltonRadix, 0);
while (seqRequest[i].haltonOffset-- >0) {
if (!optimalHalton)
nextHaltonSequencePoint(haltonID);
else
nextModHaltonSequencePoint(haltonID);
}
}
if (verbose)
fprintf(stderr, "Generating samples\n");
for (j=0; j<samples; j++) {
double CDF;
long code;
while (1) {
if (seqRequest[i].flags&SEQ_HALTONRADIX) {
if (!optimalHalton)
CDF = nextHaltonSequencePoint(haltonID);
else
CDF = nextModHaltonSequencePoint(haltonID);
}
else
CDF = random_1(1);
if (CDF<=CDFValue[values-1] && CDF>=CDFValue[0])
break;
}
sample[j]
= seqRequest[i].factor*interp(IVValue, CDFValue, values, CDF, 0, 1, &code)
+ seqRequest[i].offset;
}
if (seqRequest[i].flags&SEQ_RANDOMIZE) {
long k, l;
double *sample1;
if (verbose)
fprintf(stderr, "Randomizing order of values\n");
if (!(sample1 = malloc(sizeof(*sample1)*samples)))
SDDS_Bomb("memory allocation failure");
for (l=0; l<randomizationGroups; l++)
if (randomizationData[l].group==seqRequest[i].randomizationGroup)
break;
if (l==randomizationGroups)
SDDS_Bomb("problem with construction of randomization groups!");
for (k=0; k<samples; k++)
sample1[k] = sample[randomizationData[l].order[k]];
free(sample);
sample = sample1;
}
free(IVValue);
free(CDFValue);
}
if (verbose)
fprintf(stderr, "Setting SDDS column values\n");
if (!SDDS_SetColumnFromDoubles(&SDDSout, SDDS_SET_BY_NAME,
sample, samples,
seqRequest[i].outputName?
seqRequest[i].outputName:
seqRequest[i].indepName))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (verbose)
fprintf(stderr, "Writing data page\n");
if (!SDDS_WritePage(&SDDSout))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!requireInput)
break;
}
if (verbose)
fprintf(stderr, "Exited read loop\n");
free(sample);
if ((input && !SDDS_Terminate(&SDDSin)) || !SDDS_Terminate(&SDDSout))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (i=0; i<seqRequests; i++) {
if (seqRequest[i].dataFileName) free(seqRequest[i].dataFileName);
if (seqRequest[i].indepName) free(seqRequest[i].indepName);
if (seqRequest[i].outputName) free(seqRequest[i].outputName);
if (seqRequest[i].DFName) free(seqRequest[i].DFName);
if (seqRequest[i].CDFName) free(seqRequest[i].CDFName);
if (seqRequest[i].units) free(seqRequest[i].units);
if (seqRequest[i].meanPar) free(seqRequest[i].meanPar);
if (seqRequest[i].sigmaPar) free(seqRequest[i].sigmaPar);
if (seqRequest[i].minPar) free(seqRequest[i].minPar);
if (seqRequest[i].maxPar) free(seqRequest[i].maxPar);
if (seqRequest[i].flags&SEQ_DATAFILE && !SDDS_Terminate(&(seqRequest[i].SDDSin)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
free(seqRequest);
for (i=0; i<randomizationGroups; i++)
free(randomizationData[i].order);
if (randomizationData) free(randomizationData);
free_scanargs(&scanned, argc);
return(0);
}
void setup_coupled_twiss_output(
NAMELIST_TEXT *nltext, RUN *run, LINE_LIST *beamline, long *do_coupled_twiss_output,
long default_order)
{
/* process namelist input */
set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS);
set_print_namelist_flags(0);
if (processNamelist(&coupled_twiss_output, nltext)==NAMELIST_ERROR)
bombElegant(NULL, NULL);
if (echoNamelists) print_namelist(stdout, &coupled_twiss_output);
#if USE_MPI
if (!writePermitted)
filename = NULL;
#endif
if (filename)
filename = compose_filename(filename, run->rootname);
*do_coupled_twiss_output = output_at_each_step;
if (!emittances_from_twiss_command && emit_x==0 && sigma_dp==0)
bombElegant("supply emit_x, sigma_dp, or set emittances_from_twiss_command=1", NULL);
if (!emittances_from_twiss_command) {
if (emit_x<0)
bombElegant("emit_x < 0", NULL);
if (sigma_dp<0)
bombElegant("sigma_dp < 0", NULL);
if (emittance_ratio<0)
bombElegant("emittance_ratio < 0", NULL);
}
if (filename) {
if (!SDDS_InitializeOutput(&SDDScoupled, SDDS_BINARY, 0, NULL, NULL, filename) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "ElementName", NULL, SDDS_STRING) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "s", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "Sx", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "Sxp", "", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "Sy", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "Syp", "", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "xyTilt", "", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "Ss", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "betax1", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "betax2", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "betay1", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "betay2", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "etax", "m", SDDS_DOUBLE) ||
!SDDS_DefineSimpleColumn(&SDDScoupled, "etay", "m", SDDS_DOUBLE)) {
fprintf(stdout, "Unable to set up file %s\n", filename);
fflush(stdout);
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors);
exitElegant(1);
}
if (output_sigma_matrix) {
long maxDimension, i, j;
char name[100], units[10];
if (calculate_3d_coupling)
maxDimension = 6;
else
maxDimension = 4;
for (i=0; i<maxDimension; i++)
for (j=i; j<maxDimension; j++) {
if ((i==0 || i==2 || i==4) && (j==0 || j==2 || j==4))
strcpy_ss(units, "m$a2$n");
else if ((!(i==0 || i==2 || i==4) && (j==0 || j==2 || j==4)) ||
((i==0 || i==2 || i==4) && !(j==0 || j==2 || j==4)))
strcpy_ss(units, "m");
else
strcpy_ss(units, "");
sprintf(name, "S%ld%ld", i+1, j+1);
if (!SDDS_DefineSimpleColumn(&SDDScoupled, name, units, SDDS_DOUBLE)) {
fprintf(stdout, "Unable to set up file %s\n", filename);
fflush(stdout);
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors);
exitElegant(1);
}
}
}
if (!SDDS_WriteLayout(&SDDScoupled)) {
fprintf(stdout, "Unable to set up file %s\n", filename);
fflush(stdout);
SDDS_PrintErrors(stdout, SDDS_VERBOSE_PrintErrors);
exitElegant(1);
}
SDDScoupledInitialized = 1;
}
initialized = 1;
}
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 initializePolynomial(POLYNOMIAL *poly, SDDS_DATASET *SDDSin, SDDS_DATASET *SDDSout)
{
long i;
SDDS_DATASET SDDSpoly;
char buffer[1024];
for (i=1; i<5; i++) {
if ((poly->flags&(POLY_IN0_SEEN<<(2*i))) &&
!(poly->flags&(POLY_OUT0_SEEN<<(2*i))))
SDDS_Bomb("input qualifier seen without matching output qualifier");
if (!(poly->flags&(POLY_IN0_SEEN<<(2*i))) &&
(poly->flags&(POLY_OUT0_SEEN<<(2*i))))
SDDS_Bomb("output qualifier seen without matching input qualifier");
if (!(poly->flags&(POLY_IN0_SEEN<<(2*i))) &&
!(poly->flags&(POLY_OUT0_SEEN<<(2*i))))
break;
}
poly->nInputs = i;
for (i++; i<5; i++) {
if ((poly->flags&(POLY_IN0_SEEN<<(2*i))) ||
(poly->flags&(POLY_OUT0_SEEN<<(2*i))))
SDDS_Bomb("input<n> or output<n> qualifiers skipped");
}
if (!SDDS_InitializeInput(&SDDSpoly, poly->filename))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (SDDS_GetColumnIndex(&SDDSpoly,poly->outputColumn)==-1) {
if (!SDDS_DefineSimpleColumn(SDDSout, poly->outputColumn, NULL, SDDS_DOUBLE))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
} else {
if (SDDS_CheckColumn(&SDDSpoly, poly->outputColumn, NULL, SDDS_ANY_NUMERIC_TYPE,
stderr)!=SDDS_CHECK_OKAY)
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (SDDS_CheckColumn(&SDDSpoly, poly->coefColumn, NULL, SDDS_ANY_NUMERIC_TYPE,
stderr)!=SDDS_CHECK_OKAY)
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
for (i=0; i<poly->nInputs; i++) {
if (SDDS_CheckColumn(SDDSin, poly->inputColumn[i], NULL, SDDS_ANY_NUMERIC_TYPE,
stderr)!=SDDS_CHECK_OKAY)
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (SDDS_CheckColumn(&SDDSpoly, poly->powerColumn[i], NULL, SDDS_ANY_NUMERIC_TYPE,
stderr)!=SDDS_CHECK_OKAY)
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (SDDS_ReadPage(&SDDSpoly)<=0) {
sprintf(buffer, "problem with file %s\n", poly->filename);
SDDS_SetError(buffer);
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if ((poly->nTerms=SDDS_RowCount(&SDDSpoly))<=0) {
sprintf(buffer, "problem with file %s: no rows\n", poly->filename);
SDDS_SetError(buffer);
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!(poly->coef=SDDS_GetColumnInDoubles(&SDDSpoly, poly->coefColumn)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!(poly->power=SDDS_Malloc(sizeof(*(poly->power))*poly->nInputs)))
SDDS_Bomb("memory allocation failure");
for (i=0; i<poly->nInputs; i++) {
if (!(poly->power[i]=
SDDS_GetColumnInLong(&SDDSpoly, poly->powerColumn[i])))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
}
if (!SDDS_Terminate(&SDDSpoly))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!(poly->input = SDDS_Malloc(sizeof(*(poly->input))*poly->nInputs)))
SDDS_Bomb("memory allocation failure");
if (!(poly->inputData = SDDS_Malloc(sizeof(*(poly->inputData))*poly->nInputs)))
SDDS_Bomb("memory allocation failure");
}
int main(int argc, char *argv[]) {
char *filename=NULL;
MPI_DATASET *MPI_dataset;
SDDS_DATASET SDDS_dataset;
char buf[256];
int32_t total_rows=37500000, i, j, mpi_code, cols=8, rows, columnOrder=0, ID_offset, myid, n_processors, collective_io=0, i_arg;
double startTime =0;
MPI_Comm comm;
SCANNED_ARG *s_arg;
MPI_Init(&argc,&argv);
argc = scanargs(&s_arg, argc, argv);
if (argc<2)
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_COLUMN_ORDER:
columnOrder = 1;
break;
case SET_COLLECTIVE_IO:
collective_io = 1;
break;
case SET_TOTAL_ROWS:
if (s_arg[i_arg].n_items!=2)
SDDS_Bomb("Invalid -totalrows syntax given!");
if (!get_long(&total_rows, s_arg[i_arg].list[1]))
SDDS_Bomb("Invalid -totalrows value given!");
break;
default:
break;
}
} else if (!filename)
filename = s_arg[i_arg].list[0];
else
SDDS_Bomb("Too many files.");
}
/* 1. set the communicator for MPI IO */
SDDS_SetDefaultBufferSize(4000000);
comm = MPI_COMM_WORLD;
if (MPI_SUCCESS != (mpi_code=MPI_Comm_rank(comm, &myid)))
SDDS_MPI_GOTO_ERROR(stderr, "MPI_Comm_rank failed", mpi_code, 1);
if (MPI_SUCCESS != (mpi_code=MPI_Comm_size(comm, &n_processors)))
SDDS_MPI_GOTO_ERROR(stderr, "MPI_Comm_size failed", mpi_code, 1);
SDDS_MPI_Setup(&SDDS_dataset, 1, n_processors, myid, comm, 1);
MPI_dataset = SDDS_dataset.MPI_dataset;
/* 2. open file (all processors) */
/* 3. initialize output, right now, only write binary files (all processors) */
fprintf(stderr, "rank=%d, initialize input \n", myid);
if (!SDDS_MPI_InitializeOutput(&SDDS_dataset, NULL, NULL, filename, SDDS_MPI_WRITE_ONLY, columnOrder))
SDDS_Bomb("Unable to initalize output");
MPI_dataset->collective_io = collective_io;
for (i=0; i<cols; i++) {
sprintf(buf,"col%d", i);
if ( !SDDS_DefineSimpleColumn(&SDDS_dataset, buf, NULL, SDDS_DOUBLE))
SDDS_MPI_BOMB("SDDS define column and parameters failed.", &(MPI_dataset->MPI_file));
}
if (!SDDS_SaveLayout(&SDDS_dataset))
SDDS_MPI_BOMB("SDDS define column and parameters failed.", &(MPI_dataset->MPI_file));
fprintf(stderr, "rank=%d, layout defined. \n", myid);
startTime = MPI_Wtime();
if (!SDDS_WriteLayout(&SDDS_dataset))
SDDS_MPI_BOMB("SDDS_MPI_WriteLayout failed.", &(MPI_dataset->MPI_file));
fprintf(stderr, "rank=%d, total_rows=%d, layout written spent %f seconds. \n", myid, total_rows, MPI_Wtime() - startTime);
rows = total_rows/n_processors;
if (myid < (ID_offset=total_rows%(n_processors))) {
rows ++;
}
if (!SDDS_StartPage(&SDDS_dataset, rows))
SDDS_MPI_BOMB("SDDS start page failed.", &MPI_dataset->MPI_file);
/* 7. set data values */
for (i=0; i<rows; i++) {
for (j=0; j<cols; j++) {
sprintf(buf,"col%d", j);
if (!SDDS_SetRowValues(&SDDS_dataset, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, i,
buf, (double)i, NULL))
SDDS_MPI_BOMB("SDDS_SetRowValues failed.", &MPI_dataset->MPI_file);
}
}
fprintf(stderr, "rank=%d, row set. \n", myid);
startTime = MPI_Wtime();
if (!SDDS_WritePage(&SDDS_dataset))
SDDS_MPI_BOMB("SDDS_MPI_WritePage failed.", &MPI_dataset->MPI_file);
fprintf(stderr, "rank=%d, page write spent %f. \n", myid, MPI_Wtime() - startTime);
if (!SDDS_Terminate(&SDDS_dataset))
SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors|SDDS_VERBOSE_PrintErrors);
/* close file is done inside SDDS_MPI_Terminate*/
MPI_Finalize();
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);
}
