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) { SCANNED_ARG *scanned; char *inputfile, *outputfile; SDDS_DATASET twissPage, resultsPage; double particles, charge, length; long verbosity, noWarning, i, elements, superperiods, growthRatesOnly, force; double pCentral0, I1, I2, I3, I4, I5, taux, tauy, taudelta; double EMeV; double emitx0, emitx, emitxInput, emityInput, emity, coupling, sigmaz0, sigmaz; double sigmaDelta0, sigmaDelta, sigmaDeltaInput, xGrowthRate, yGrowthRate, zGrowthRate; double xGrowthRateInitial, yGrowthRateInitial, zGrowthRateInitial; double emitxOld, sigmaDeltaOld; long method, converged; /* used in simplex minimization */ double yReturn, *xGuess, *dxGuess, *xLowerLimit, *xUpperLimit; short *disable; long dimensions = 15, maxEvaluations = 500, maxPasses = 2; double target = 1e-6; int32_t integrationTurns, integrationStepSize; long integrationPoints = 0; double *exInteg=NULL, *eyInteg=NULL, *elInteg=NULL, *xRateInteg=NULL, *yRateInteg=NULL, *zRateInteg=NULL; double *SdeltaInteg=NULL, *SzInteg=NULL; int32_t *passInteg=NULL; unsigned long dummyFlags; double rfVoltage, rfHarmonic; double alphac, U0, circumference, energy; double *xRateVsS, *yRateVsS, *zRateVsS; SDDS_RegisterProgramName(argv[0]); argc = scanargs(&scanned, argc, argv); if (argc == 1) bomb(NULL, USAGE); xRateVsS = yRateVsS = zRateVsS = NULL; inputfile = NULL; outputfile = NULL; energy = 0; verbosity = 0; isRing = 1; particles = 0; charge = 0; coupling = emityInput = 0; force = 1; length = 0; superperiods=1; method = 0; emitxInput = 0; sigmaDeltaInput = 0; growthRatesOnly = 0; integrationTurns = 0; rfVoltage = rfHarmonic = 0; noWarning = 0; for (i = 1; i<argc; i++) { if (scanned[i].arg_type == OPTION) { delete_chars(scanned[i].list[0], "_"); switch(match_string(scanned[i].list[0], option, N_OPTIONS, UNIQUE_MATCH)) { case VERBOSE: if(scanned[i].n_items > 1 ) { get_long(&verbosity, scanned[i].list[1]); } else { verbosity=1; } break; case ISRING: if(scanned[i].n_items > 1 ) { get_long(&isRing, scanned[i].list[1]); } else { isRing=1; } break; case CHARGE: get_double(&charge, scanned[i].list[1]); break; case EMITXINPUT: /* This is really the emitx+emity, not emitx */ get_double(&emitxInput, scanned[i].list[1]); break; case EMITINPUT: get_double(&emitxInput, scanned[i].list[1]); break; case DELTAINPUT: get_double(&sigmaDeltaInput, scanned[i].list[1]); break; case LENGTH: get_double(&length, scanned[i].list[1]); length /= 1000; /* convert input length from mm to m */ break; case COUPLING: get_double(&coupling, scanned[i].list[1]); break; case EMITYINPUT: get_double(&emityInput, scanned[i].list[1]); break; case FORCECOUPLING: get_long(&force, scanned[i].list[1]); break; case PARTICLES: get_double(&particles, scanned[i].list[1]); break; case SUPERPERIOD: get_long(&superperiods, scanned[i].list[1]); break; case METHOD: get_long(&method, scanned[i].list[1]); break; case GROWTHRATESONLY: growthRatesOnly = 1; break; case SET_TARGET: if (scanned[i].n_items!=2 || !get_double(&target, scanned[i].list[1]) || target<0) bomb("invalid -target syntax", NULL); break; case RF: if (scanned[i].n_items<2) bomb("invalid -rf syntax", NULL); scanned[i].n_items--; rfVoltage = rfHarmonic = 0; if (!scanItemList(&dummyFlags, scanned[i].list+1, &scanned[i].n_items, 0, "voltage", SDDS_DOUBLE, &rfVoltage, 1, 0, "harmonic", SDDS_DOUBLE, &rfHarmonic, 1, 0, NULL) || rfVoltage<=0 || rfHarmonic<=0) bomb("invalid -rf syntax/values", "-rf=voltage=MV,harmonic=<value>"); break; case SET_ENERGY: if (scanned[i].n_items!=2) bomb("invalid -energy syntax", NULL); if (!sscanf(scanned[i].list[1], "%lf", &energy) || energy<=0) bomb("invalid -energy syntax/values", "-energy=<MeV>"); break; case SET_INTEGRATE: if (scanned[i].n_items<2) bomb("invalid -integrate syntax", NULL); integrationTurns = 0; integrationStepSize = 1; scanned[i].n_items--; if (!scanItemList(&dummyFlags, scanned[i].list+1, &scanned[i].n_items, 0, "turns", SDDS_LONG, &integrationTurns, 1, 0, "stepsize", SDDS_LONG, &integrationStepSize, 1, 0, NULL) || integrationTurns<=0 || integrationStepSize<1) bomb("invalid -integrate syntax", NULL); break; case NO_WARNING: noWarning = 1; break; default: fprintf(stderr, "Unknown option %s given", scanned[i].list[0]); exit(1); break; } } else { if (!inputfile) inputfile = scanned[i].list[0]; else if (!outputfile) outputfile = scanned[i].list[0]; else bomb("too many filenames given", NULL); } } if (charge && particles) { bomb("Options charge and particles cannot be both specified.",NULL); } if (!charge) charge = particles * e_mks; if (!particles) { /* command line input value is in units of nC */ charge /= 1e9; particles = charge/ e_mks; } if ((!coupling && !emityInput) || (coupling && emityInput)) bomb("Give -coupling or -emityInput (but not both)", NULL); if (!length && !rfVoltage) bomb("Specify either the bunch length or the rf voltage.", NULL); if (growthRatesOnly && integrationTurns) { growthRatesOnly = 0; if (!noWarning) fprintf( stdout, "*Warning* -growthRatesOnly option is incompatiable with -integrate option. The -growthRatesOnly will be disabled.\n"); } if (!growthRatesOnly && !integrationTurns && !noWarning) fprintf( stdout, "*Warning* The growth rate contribution columns in the results file will be those calculated from the equilibrium (or final) condition.\n"); if (integrationTurns && !isRing) { integrationTurns = 0; fprintf( stdout, "*Warning* -isRing=0 is incompatiable with -integrate option. The -integrate will be disabled.\n"); } if (energy && !isRing) { energy = 0; fprintf( stdout, "*Warning* you can not scale energy for linac beam. Scaling will be disabled.\n"); } /***************************************************\ * get parameter information from first input file * \***************************************************/ if (verbosity) fprintf( stdout, "Opening \"%s\" for checking presence of parameters.\n", inputfile); if (!SDDS_InitializeInput(&twissPage, inputfile)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /* read first page of input file to get parameters I1 I2 I3 I4 I5. Check presence of first radiation integral. */ SDDS_ReadPage(&twissPage); /* parameter Type */ switch(SDDS_CheckParameter(&twissPage, "I1", NULL, SDDS_DOUBLE, verbosity?stdout:NULL)) { case SDDS_CHECK_NONEXISTENT: if (verbosity) fprintf( stdout, "\tParameter I1 not found in input file.\n"); break; case SDDS_CHECK_WRONGTYPE: SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); exitElegant(1); break; case SDDS_CHECK_OKAY: break; default: fprintf( stdout, "Unexpected result from SDDS_CheckParameter routine while checking parameter Type.\n"); SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); exitElegant(1); break; } if (verbosity) fprintf( stdout, "Opening \"%s\" for writing...\n", outputfile); if (!SDDS_InitializeOutput(&resultsPage, SDDS_BINARY, 1, "Intra-beam scattering rates", "Intra-beam scattering rates", outputfile)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (!SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "I1", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "I2", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "I3", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "I4", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "I5", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "pCentral", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "taux", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "tauy", NULL) || !SDDS_TransferParameterDefinition(&resultsPage, &twissPage, "taudelta", NULL) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (0>SDDS_DefineParameter(&resultsPage, "Superperiods", NULL, NULL, "Superperiods", NULL, SDDS_LONG, NULL) || 0>SDDS_DefineParameter(&resultsPage, "Energy", "E", "MeV", "Total Energy", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "Particles", NULL, NULL, "Particles", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "Charge", NULL, "nC", "Charge", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "PeakCurrent", "I$bp$n", "A", "Peak Current", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "RfVoltage", NULL, "MV", "Rf Voltage", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "xGrowthRateInitial", "g$bIBS,x$n", "1/s", "Initial IBS emittance growth rate in the horizontal plane", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "yGrowthRateInitial", "g$bIBS,y$n", "1/s", "Initial IBS emittance growth rate in the vertical plane", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "zGrowthRateInitial", "g$bIBS,z$n", "1/s", "Initial IBS emittance growth rate in the longitudinal plane", NULL, SDDS_DOUBLE, NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (0>SDDS_DefineParameter(&resultsPage, "Convergence", NULL, NULL, "Convergence state of emittance calculations", NULL, SDDS_STRING, NULL) || 0>SDDS_DefineParameter(&resultsPage, "emitx0", "$ge$r$bx,0$n", "$gp$rm", "Equilibrium horizontal emittance with no coupling and no IBS", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "emitxInput", "$ge$r$bx,Input$n", "$gp$rm", "Initial horizontal emittance with coupling", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "emityInput", "$ge$r$by,Input$n", "$gp$rm", "Initial vertical emittance with coupling", NULL, SDDS_DOUBLE, NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); /* requested equilibrium emittances or integrate emittances turn-by-turn*/ if (!growthRatesOnly) { if (0>SDDS_DefineParameter(&resultsPage, "xGrowthRate", "g$bIBS,x$n", "1/s", "IBS emittance growth rate in the horizontal plane", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "yGrowthRate", "g$bIBS,y$n", "1/s", "IBS emittance growth rate in the vertical plane", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "zGrowthRate", "g$bIBS,z$n", "1/s", "IBS emittance growth rate in the longitudinal plane", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "emitx", "$ge$r$bx$n", "$gp$rm", "Horizontal emittance with coupling and with IBS", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "emity", "$ge$r$by$n", "$gp$rm", "Vertical emittance with coupling and with IBS", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "sigmaDelta", "$gs$r$bd$n", NULL, "Relative momentum spread with IBS", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "sigmaz", "$gs$r$bz$n", "m", "Bunch length with IBS", NULL, SDDS_DOUBLE, NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (0>SDDS_DefineParameter(&resultsPage, "sigmaDelta0", "$gs$r$bd,0$n", NULL, "Equilibrium relative momentum spread without IBS", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "sigmaDeltaInput", "$gs$r$bd,0$n", NULL, "Initial relative momentum spread", NULL, SDDS_DOUBLE, NULL) || 0>SDDS_DefineParameter(&resultsPage, "sigmaz0", "$gs$r$bz,0$n", "m", "Bunch length without IBS", NULL, SDDS_DOUBLE, NULL)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (verbosity) fprintf( stdout, "Opening for reading \"%s\"\n", inputfile); if (!SDDS_InitializeInput(&twissPage, inputfile)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); if (integrationTurns) { if (SDDS_DefineColumn(&resultsPage, "ex", "$ge$r$bx$n", "$gp$rm", "Horizontal Emittance", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "ey", "$ge$r$by$n", "$gp$rm", "Vertical Emittance", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "el", "$ge$r$bl$n", "s", "Longitudinal Emittance", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "Sdelta", "$gs$bd$n$r", "", "Fractional RMS Energy Spread", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "Sz", "$gs$r$bz$n", "m", "RMS Bunch Length", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "IBSRatex", NULL, "1/s", "Horizontal IBS Emittance Growth Rate", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "IBSRatey", NULL, "1/s", "Vertical IBS Emittance Growth Rate", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "IBSRatel", NULL, "1/s", "Longitudinal IBS Emittance Growth Rate", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "Pass", NULL, NULL, NULL, NULL, SDDS_LONG, 0)<0) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); integrationPoints = integrationTurns/integrationStepSize+1; if (!(exInteg = SDDS_Malloc(sizeof(*exInteg)*integrationPoints)) || !(eyInteg = SDDS_Malloc(sizeof(*eyInteg)*integrationPoints)) || !(elInteg = SDDS_Malloc(sizeof(*elInteg)*integrationPoints)) || !(SdeltaInteg = SDDS_Malloc(sizeof(*SdeltaInteg)*integrationPoints)) || !(SzInteg = SDDS_Malloc(sizeof(*SzInteg)*integrationPoints)) || !(xRateInteg = SDDS_Malloc(sizeof(*xRateInteg)*integrationPoints)) || !(yRateInteg = SDDS_Malloc(sizeof(*yRateInteg)*integrationPoints)) || !(zRateInteg = SDDS_Malloc(sizeof(*zRateInteg)*integrationPoints)) || !(passInteg = SDDS_Malloc(sizeof(*passInteg)*integrationPoints))) bomb("memory allocation failure (integration arrays)", NULL); } else { if (SDDS_DefineColumn(&resultsPage, "s", NULL, "m", "Position", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "dIBSRatex", NULL, "1/s", "Local Horizontal IBS Emittance Growth Rate", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "dIBSRatey", NULL, "1/s", "Local Vertical IBS Emittance Growth Rate", NULL, SDDS_DOUBLE, 0)<0 || SDDS_DefineColumn(&resultsPage, "dIBSRatel", NULL, "1/s", "Local Longitudinal IBS Emittance Growth Rate", NULL, SDDS_DOUBLE, 0)<0) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_WriteLayout(&resultsPage) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); while(SDDS_ReadPage(&twissPage)>0) { if (!SDDS_GetParameters(&twissPage, "pCentral", &pCentral0, "I1", &I1, "I2", &I2, "I3", &I3, "I4", &I4, "I5", &I5, "taux", &taux, "tauy", &tauy, "taudelta", &taudelta, "alphac", &alphac, "U0", &U0, NULL) ) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); EMeV = sqrt(sqr(pCentral0) + 1) * me_mev; elements = SDDS_CountRowsOfInterest(&twissPage); s = SDDS_GetColumnInDoubles(&twissPage, "s"); pCentral = SDDS_GetColumnInDoubles(&twissPage, "pCentral0"); circumference = s[elements-1]*superperiods; U0 *= superperiods; if (energy!=0) { /* scale to new energy */ pCentral0 = sqrt(sqr(energy/me_mev)-1); taux /= ipow(energy/EMeV, 3); tauy /= ipow(energy/EMeV, 3); taudelta /= ipow(energy/EMeV, 3); U0 *= ipow(energy/EMeV, 4); for (i=0; i<elements; i++) pCentral[i] = pCentral0; EMeV = energy; } if (!length && U0>rfVoltage) bomb("energy loss per turn is greater than rf voltage", NULL); betax = SDDS_GetColumnInDoubles(&twissPage, "betax"); betay = SDDS_GetColumnInDoubles(&twissPage, "betay"); alphax = SDDS_GetColumnInDoubles(&twissPage, "alphax"); alphay = SDDS_GetColumnInDoubles(&twissPage, "alphay"); etax = SDDS_GetColumnInDoubles(&twissPage, "etax"); etaxp = SDDS_GetColumnInDoubles(&twissPage, "etaxp"); etay = SDDS_GetColumnInDoubles(&twissPage, "etay"); etayp = SDDS_GetColumnInDoubles(&twissPage, "etayp"); /* emitx0 and sigmaDelta0 are unperturbed quantities (i.e. no coupling and no IBS) that zibs requires to internally calculate the quantum excitation. (zibs doesn't use the radiation integrals but should!) */ emitx0 = 55.0/ (32.*sqrt(3.)) * hbar_mks * sqr(pCentral0)/ (me_mks * c_mks) * I5 / (I2 - I4); sigmaDelta0 = sqrt(55.0/ (32.*sqrt(3.)) * hbar_mks * sqr(pCentral0)/ (me_mks * c_mks) * I3 / (2 * I2 + I4)); /* use unperturbed quantities in no input supplied. */ if (!sigmaDeltaInput) sigmaDeltaInput = sigmaDelta0; if (!emitxInput) emitxInput = emitx0/ ( 1 + coupling); else /* The emitxInput value is really emit=emitx+emity */ emitxInput = emitxInput/ ( 1 + coupling); if (!emityInput) emityInput = emitxInput * coupling; else coupling = emityInput/emityInput; sigmaDelta = sigmaDeltaInput; if (length) sigmaz0 = length; else { /* compute length in m from rf voltage, energy spread, etc */ sigmaz0 = circumference*sigmaDelta* sqrt(alphac*EMeV/(PIx2*rfHarmonic*sqrt(sqr(rfVoltage)-sqr(U0)))); } sigmaz = sigmaz0; emity = emityInput; emitx = emitxInput; if (integrationPoints) { IBSIntegrate(exInteg, eyInteg, elInteg, passInteg, SdeltaInteg, SzInteg, xRateInteg, yRateInteg, zRateInteg, integrationTurns, integrationStepSize, pCentral0, emitx, emity, sigmaDelta, sigmaz, particles, emitx0, sigmaDelta0, 2./taux, 2./tauy, 2./taudelta, coupling, s, pCentral, betax, alphax, betay, alphay, etax, etaxp, etay, etayp, elements, superperiods, verbosity, isRing, force); } else { if (!(xRateVsS = SDDS_Realloc(xRateVsS, sizeof(*xRateVsS)*elements)) || !(yRateVsS = SDDS_Realloc(yRateVsS, sizeof(*yRateVsS)*elements)) || !(zRateVsS = SDDS_Realloc(zRateVsS, sizeof(*zRateVsS)*elements)) ) bomb("memory allocation failure", NULL); } /* This call is to get the initial growth rates for writing to results file. This applies for any running option selected in the commandline */ IBSRate(particles, elements, superperiods, verbosity, isRing, emitx, emity, sigmaDelta, sigmaz, s, pCentral, betax, alphax, betay, alphay, etax, etaxp, etay, etayp, NULL, NULL, NULL, &xGrowthRateInitial, &yGrowthRateInitial, &zGrowthRateInitial, 0); /* iterating for equilibrium emittances and final growth rates */ if (!integrationTurns && !growthRatesOnly && isRing) { if (verbosity > 1) { fprintf (stdout, "Starting values:\nemitx: %10.5g sigmaDelta %10.5g.\n", emitx, sigmaDelta); } emitxOld = emitx; sigmaDeltaOld = sigmaDelta; xGuess = (double*) malloc(sizeof(double)*dimensions); dxGuess = (double*) malloc(sizeof(double)*dimensions); xLowerLimit = (double*) malloc(sizeof(double)*dimensions); xUpperLimit = (double*) malloc(sizeof(double)*dimensions); disable = (short*) malloc(sizeof(short)*dimensions); xGuess[0] = MAX(emitx, emitx0/ (1 + coupling)); xGuess[1] = MAX(sigmaDelta, sigmaDelta0); dxGuess[0] = emitx * 0.1; dxGuess[1] = sigmaDelta * 0.1; xLowerLimit[0] = emitx0/ (1 + coupling); xLowerLimit[1] = sigmaDelta0; xUpperLimit[0] = emitx0/ (1 + coupling) * 200; xUpperLimit[1] = MIN(sigmaDelta0 * 100, 1.0); /* assign other variables to array which are not supoosed to be varied by simplex minimization */ xGuess[2] = pCentral0; xGuess[3] = emity; xGuess[4] = sigmaz0; xGuess[5] = particles; xGuess[6] = emitx0; xGuess[7] = sigmaDelta0; xGuess[8] = taux; xGuess[9] = tauy; xGuess[10] = taudelta; xGuess[11] = coupling; xGuess[12] = elements; xGuess[13] = superperiods; xGuess[14] = verbosity; xLowerLimit[2] = pCentral0; xLowerLimit[3] = emity; xLowerLimit[4] = sigmaz0; xLowerLimit[5] = particles; xLowerLimit[6] = emitx0; xLowerLimit[7] = sigmaDelta0; xLowerLimit[8] = taux; xLowerLimit[9] = tauy; xLowerLimit[10] = taudelta; xLowerLimit[11] = coupling; xLowerLimit[12] = elements; xLowerLimit[13] = superperiods; xLowerLimit[14] = verbosity; xUpperLimit[2] = pCentral0; xUpperLimit[3] = emity; xUpperLimit[4] = sigmaz0; xUpperLimit[5] = particles; xUpperLimit[6] = emitx0; xUpperLimit[7] = sigmaDelta0; xUpperLimit[8] = taux; xUpperLimit[9] = tauy; xUpperLimit[10] = taudelta; xUpperLimit[11] = coupling; xUpperLimit[12] = elements; xUpperLimit[13] = superperiods; xUpperLimit[14] = verbosity; disable[0] = 0; disable[1] = 0; for (i=2 ; i<dimensions ; i++) { dxGuess[i] = 0.0; disable[i] = 1; } if (verbosity) { fprintf( stdout, "Doing simplex minimization...\n"); } simplexMin( &yReturn, xGuess, dxGuess, xLowerLimit, xUpperLimit, disable, dimensions, target, target/100.0, IBSequations, verbosity?IBSsimplexReport:NULL, maxEvaluations, maxPasses, 12, 3.0, 1.0, 0); /* final answers */ emitx = xGuess[0]; sigmaDelta = xGuess[1]; emity = emitx * coupling; sigmaz = sigmaz0 * (sigmaDelta/ sigmaDelta0); } /* calculate growth rates contributions at equilibrium or just one time (-growthRateOnly option) */ if (!integrationPoints) { IBSRate(particles, elements, superperiods, verbosity, isRing, emitx, emity, sigmaDelta, sigmaz, s, pCentral, betax, alphax, betay, alphay, etax, etaxp, etay, etayp, xRateVsS, yRateVsS, zRateVsS, &xGrowthRate, &yGrowthRate, &zGrowthRate, 0); } else { /* final growth rates and emittances after integration */ xGrowthRate = xRateInteg[integrationPoints - 1] ; yGrowthRate = yRateInteg[integrationPoints - 1] ; zGrowthRate = zRateInteg[integrationPoints - 1] ; emitx = exInteg[integrationPoints - 1] ; emity = eyInteg[integrationPoints - 1] ; sigmaDelta = SdeltaInteg[integrationPoints - 1] ; sigmaz = SzInteg[integrationPoints - 1] ; } converged = 1; if (0>SDDS_StartPage(&resultsPage, integrationPoints?integrationPoints:elements) || !SDDS_SetParameters(&resultsPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "Convergence", converged?"Emittance converged":"Emittance did not converge", "pCentral", pCentral0, "RfVoltage", rfVoltage, "I1", I1, "I2", I2, "I3", I3, "I4", I4, "I5", I5, "taux", taux, "tauy", tauy, "taudelta", taudelta, "Energy", EMeV, "Particles", particles, "Charge", (1e9 * charge), "PeakCurrent", (charge*c_mks/(sqrt(2*PI)*sigmaz)), "Superperiods", superperiods, "emitx0", emitx0, "emitxInput", emitxInput, "emityInput", emityInput, "xGrowthRateInitial", xGrowthRateInitial, "yGrowthRateInitial", yGrowthRateInitial, "zGrowthRateInitial", zGrowthRateInitial, "sigmaDeltaInput", sigmaDeltaInput, "sigmaDelta0", sigmaDelta0, "sigmaz0", sigmaz0, NULL) || (!growthRatesOnly && !SDDS_SetParameters(&resultsPage, SDDS_SET_BY_NAME|SDDS_PASS_BY_VALUE, "xGrowthRate", xGrowthRate, "yGrowthRate", yGrowthRate, "zGrowthRate", zGrowthRate, "emitx", emitx, "emity", emity, "sigmaDelta", sigmaDelta, "sigmaz", sigmaz, NULL)) || (integrationPoints && (!SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, exInteg, integrationPoints, "ex") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, eyInteg, integrationPoints, "ey") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, elInteg, integrationPoints, "el") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, SdeltaInteg, integrationPoints, "Sdelta") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, SzInteg, integrationPoints, "Sz") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, xRateInteg, integrationPoints, "IBSRatex") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, yRateInteg, integrationPoints, "IBSRatey") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, zRateInteg, integrationPoints, "IBSRatel") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, passInteg, integrationPoints, "Pass"))) || (!integrationPoints && (!SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, s, elements, "s") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, xRateVsS, elements, "dIBSRatex") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, yRateVsS, elements, "dIBSRatey") || !SDDS_SetColumn(&resultsPage, SDDS_SET_BY_NAME, zRateVsS, elements, "dIBSRatel"))) || !SDDS_WritePage(&resultsPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); } if (!SDDS_Terminate(&twissPage) || !SDDS_Terminate(&resultsPage)) SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors); 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); }