void swap_create_graph(char * datadir)
{
char *rrd_path;
char free_def[BUFF_SIZE];
char used_def[BUFF_SIZE];
char total_def[BUFF_SIZE];
char * params[] = {
"load",
"./swap.png",
"--imgformat", "PNG",
"--title", "swap stats",
"--vertical-label", "RAM",
"--width", "700",
"--height", "400",
"--lower-limit", "0",
"DEF:free=swap.rrd:free:AVERAGE", /* 14 */
"DEF:used=swap.rrd:used:AVERAGE", /* 15 */
"DEF:total=swap.rrd:total:AVERAGE", /* 16 */
"VDEF:freeavg=free,AVERAGE",
"VDEF:freemax=free,MAXIMUM",
"VDEF:freemin=free,MINIMUM",
"VDEF:usedavg=used,AVERAGE",
"VDEF:usedmax=used,MAXIMUM",
"VDEF:usedmin=used,MINIMUM",
"VDEF:totalavg=total,AVERAGE",
"VDEF:totalmax=total,MAXIMUM",
"VDEF:totalmin=total,MINIMUM",
"COMMENT: Average Maximum Minimum\\l",
"AREA:used#F00:Used :STACK",
"GPRINT:usedavg:%7.2lfM",
"GPRINT:usedmax:%7.2lfM",
"GPRINT:usedmin:%7.2lfM\\l",
"LINE2:total#000:Total ",
"GPRINT:totalavg:%7.2lfM",
"GPRINT:totalmax:%7.2lfM",
"GPRINT:totalmin:%7.2lfM"
};
rrd_path = compose_filename(datadir, "swap.rrd");
params[14] = free_def;
params[15] = used_def;
params[16] = total_def;
snprintf(params[14], BUFF_SIZE, "DEF:free=%s:free:AVERAGE", rrd_path);
snprintf(params[15], BUFF_SIZE, "DEF:used=%s:used:AVERAGE", rrd_path);
snprintf(params[16], BUFF_SIZE, "DEF:total=%s:total:AVERAGE", rrd_path);
if (!rrd_db_exists(datadir, "swap.rrd")) swap_create_rrd(datadir);
rrd_create_graph(datadir, "swap.png", sizeof(params) / sizeof(char *), params);
free(rrd_path);
}
int main(int argc, char *argv[])
{
libbase::cputimer tmain("Main timer");
// Set up user parameters
namespace po = boost::program_options;
po::options_description desc("Allowed options");
desc.add_options()("help", "print this help message");
desc.add_options()("tau,t", po::value<int>(), "interleaver length");
desc.add_options()("spread,s", po::value<int>(),
"interleaver spread to start with");
desc.add_options()("attempts,n", po::value<int>()->default_value(1000),
"number of attempts before reducing spread");
po::variables_map vm;
po::store(po::parse_command_line(argc, argv, desc), vm);
po::notify(vm);
// Validate user parameters
if (vm.count("help"))
{
std::cerr << desc << std::endl;
return 1;
}
// Interpret arguments
const int tau = vm["tau"].as<int> ();
int spread = vm["spread"].as<int> ();
const int max_attempts = vm["attempts"].as<int> ();
// Main process
libbase::int32u seed = 0;
myvector<int> lut = create_srandom(tau, spread, seed, max_attempts);
// Output
const std::string fname = compose_filename(tau, spread, seed);
std::ofstream file(fname.c_str());
serialize_interleaver(file, lut, tau, spread, seed, tmain.elapsed());
return 0;
}
void net_create_graph(char * datadir)
{
char *rrd_path;
char download_def[BUFF_SIZE];
char upload_def[BUFF_SIZE];
char * params[] = {
"load",
"net.png",
"--imgformat", "PNG",
"--title", "Network stats",
"--vertical-label", "bytes/sec",
"--width", "700",
"--height", "400",
"--lower-limit", "0",
"DEF:download=net.rrd:download:AVERAGE", /* 14 */
"DEF:upload=net.rrd:upload:AVERAGE", /* 15 */
"LINE:download#0F0:Download",
"GPRINT:download:MAX:Max download\\: %2.2lf bytes/sec",
"LINE:upload#00F:Upload",
"GPRINT:upload:MAX:Max upload\\: %2.2lf bytes/sec",
};
rrd_path = compose_filename(datadir, "net.rrd");
params[14] = download_def;
params[15] = upload_def;
snprintf(params[14], BUFF_SIZE, "DEF:download=%s:download:AVERAGE", rrd_path);
snprintf(params[15], BUFF_SIZE, "DEF:upload=%s:upload:AVERAGE", rrd_path);
if (!rrd_db_exists(datadir, "net.rrd")) net_create_rrd(datadir);
rrd_create_graph(datadir, "net.png", sizeof(params) / sizeof(char *), params);
free(rrd_path);
}
void setup_chromaticity_correction(NAMELIST_TEXT *nltext, RUN *run, LINE_LIST *beamline, CHROM_CORRECTION *chrom)
{
VMATRIX *M;
ELEMENT_LIST *eptr, *elast;
#include "chrom.h"
unsigned long unstable;
log_entry("setup_chromaticity_correction");
cp_str(&sextupoles, "sf sd");
/* process namelist input */
set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS);
set_print_namelist_flags(0);
if (processNamelist(&chromaticity, nltext)==NAMELIST_ERROR)
bombElegant(NULL, NULL);
str_toupper(sextupoles);
if (echoNamelists) print_namelist(stdout, &chromaticity);
if (run->default_order<2)
bombElegant("default order must be >= 2 for chromaticity correction", NULL);
if (chrom->name)
tfree(chrom->name);
chrom->name = tmalloc(sizeof(*chrom->name)*(chrom->n_families=1));
while ((chrom->name[chrom->n_families-1]=get_token(sextupoles)))
chrom->name = trealloc(chrom->name, sizeof(*chrom->name)*(chrom->n_families+=1));
if ((--chrom->n_families)<1)
bombElegant("too few sextupoles given for chromaticity correction", NULL);
chrom->chromx = dnux_dp;
chrom->chromy = dnuy_dp;
chrom->n_iterations = n_iterations;
chrom->correction_fraction = correction_fraction;
alter_defined_values = change_defined_values;
chrom->strengthLimit = strength_limit;
chrom->use_perturbed_matrix = use_perturbed_matrix;
chrom->sextupole_tweek = sextupole_tweek;
chrom->tolerance = tolerance;
verbosityLevel = verbosity;
chrom->exit_on_failure = exit_on_failure;
if (!use_perturbed_matrix) {
if (!beamline->twiss0 || !beamline->matrix) {
double beta_x, alpha_x, eta_x, etap_x;
double beta_y, alpha_y, eta_y, etap_y;
fprintf(stdout, "Computing periodic Twiss parameters.\n");
fflush(stdout);
if (!beamline->twiss0)
beamline->twiss0 = tmalloc(sizeof(*beamline->twiss0));
eptr = beamline->elem_twiss = &(beamline->elem);
elast = eptr;
while (eptr) {
if (eptr->type==T_RECIRC)
beamline->elem_twiss = beamline->elem_recirc = eptr;
elast = eptr;
eptr = eptr->succ;
}
if (beamline->links) {
/* rebaseline_element_links(beamline->links, run, beamline); */
if (assert_element_links(beamline->links, run, beamline, STATIC_LINK+DYNAMIC_LINK)) {
beamline->flags &= ~BEAMLINE_CONCAT_CURRENT;
beamline->flags &= ~BEAMLINE_TWISS_CURRENT;
beamline->flags &= ~BEAMLINE_RADINT_CURRENT;
}
}
M = beamline->matrix = compute_periodic_twiss(&beta_x, &alpha_x, &eta_x, &etap_x, beamline->tune,
&beta_y, &alpha_y, &eta_y, &etap_y, beamline->tune+1,
beamline->elem_twiss, NULL, run,
&unstable, NULL, NULL);
beamline->twiss0->betax = beta_x;
beamline->twiss0->alphax = alpha_x;
beamline->twiss0->phix = 0;
beamline->twiss0->etax = eta_x;
beamline->twiss0->etapx = etap_x;
beamline->twiss0->betay = beta_y;
beamline->twiss0->alphay = alpha_y;
beamline->twiss0->phiy = 0;
beamline->twiss0->etay = eta_y;
beamline->twiss0->etapy = etap_y;
propagate_twiss_parameters(beamline->twiss0, beamline->tune, beamline->waists,
NULL, beamline->elem_twiss, run, NULL,
beamline->couplingFactor);
}
if (!(M=beamline->matrix) || !M->C || !M->R || !M->T)
bombElegant("something wrong with transfer map for beamline (setup_chromaticity_correction)", NULL);
computeChromCorrectionMatrix(run, beamline, chrom);
}
#if USE_MPI
if (!writePermitted)
strength_log = NULL;
#endif
if (strength_log) {
strength_log = compose_filename(strength_log, run->rootname);
fp_sl = fopen_e(strength_log, "w", 0);
fprintf(fp_sl, "SDDS1\n&column name=Step, type=long, description=\"Simulation step\" &end\n");
fprintf(fp_sl, "&column name=K2, type=double, units=\"1/m$a2$n\" &end\n");
fprintf(fp_sl, "&column name=SextupoleName, type=string &end\n");
fprintf(fp_sl, "&data mode=ascii, no_row_counts=1 &end\n");
fflush(fp_sl);
}
log_exit("setup_chromaticity_correction");
}
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;
}
void set_up_ztransverse(ZTRANSVERSE *ztransverse, RUN *run, long pass, long particles, CHARGE *charge,
double timeSpan)
{
long i, nfreq;
double df;
if (charge) {
ztransverse->macroParticleCharge = charge->macroParticleCharge;
} else if (pass==0) {
ztransverse->macroParticleCharge = 0;
if (ztransverse->charge<0)
bombElegant("ZTRANSVERSE charge parameter should be non-negative. Use change_particle to set particle charge state.", NULL);
#if (!USE_MPI)
if (particles)
ztransverse->macroParticleCharge = ztransverse->charge/particles;
#else
if (USE_MPI) {
long particles_total;
MPI_Allreduce(&particles, &particles_total, 1, MPI_LONG, MPI_SUM, workers);
if (particles_total)
ztransverse->macroParticleCharge = ztransverse->charge/particles_total;
}
#endif
}
if (ztransverse->initialized)
return;
ztransverse->SDDS_wake_initialized = 0;
if (ztransverse->broad_band) {
/* Use impedance Z = -i*wr/w*Rs/(1 + i*Q(w/wr-wr/w))
*/
double term;
if (ztransverse->bin_size<=0)
bombElegant("bin_size must be positive for ZTRANSVERSE element", NULL);
if (ztransverse->n_bins%2!=0)
bombElegant("ZTRANSVERSE element must have n_bins divisible by 2", NULL);
if (ztransverse->ZxReal || ztransverse->ZxImag ||
ztransverse->ZyReal || ztransverse->ZyImag )
bombElegant("can't specify both broad_band impedance and Z(f) files for ZTRANSVERSE element", NULL);
optimizeBinSettingsForImpedance(timeSpan, ztransverse->freq, ztransverse->Q,
&(ztransverse->bin_size), &(ztransverse->n_bins),
ztransverse->max_n_bins);
nfreq = ztransverse->n_bins/2 + 1;
ztransverse->iZ[0] = tmalloc(sizeof(**(ztransverse->iZ))*ztransverse->n_bins);
ztransverse->iZ[1] = tmalloc(sizeof(**(ztransverse->iZ))*ztransverse->n_bins);
/* df is the frequency spacing normalized to the resonant frequency */
df = 1/(ztransverse->n_bins*ztransverse->bin_size)/(ztransverse->freq);
/* DC term of iZ is 0 */
ztransverse->iZ[0][0] = ztransverse->iZ[1][0] = 0;
for (i=1; i<nfreq-1; i++) {
term = ztransverse->Q*(i*df-1.0/(i*df));
/* real part of i*Z */
ztransverse->iZ[0][2*i-1] =
ztransverse->iZ[1][2*i-1] =
ztransverse->Rs/(i*df)/(1+term*term);
/* imaginary part of i*Z is -Real[i*Z]*term */
ztransverse->iZ[0][2*i] =
ztransverse->iZ[1][2*i] =
-term*ztransverse->iZ[0][2*i-1];
}
/* Nyquist term--real part of iZ only */
term = ztransverse->Q*(1.0/(nfreq*df)-nfreq*df);
ztransverse->iZ[0][ztransverse->n_bins-1] =
ztransverse->iZ[1][ztransverse->n_bins-1] =
ztransverse->Rs/(nfreq*df)/(1+term*term);
df *= ztransverse->freq;
} else {
double *ZReal[2], *ZImag[2], *freqData;
double df_spect;
long n_spect;
SDDS_DATASET SDDSin;
if (!ztransverse->freqColumn || !ztransverse->inputFile)
bombElegant("you must give an inputFile and freqColumn, or use a broad band model (ZTRANSVERSE)", NULL);
if (!ztransverse->ZxReal && !ztransverse->ZxImag &&
!ztransverse->ZyReal && !ztransverse->ZxImag)
bombElegant("you must either give broad_band=1, or Z[xy]Real and/or Z[xy]Imag (ZTRANSVERSE)", NULL);
if (!SDDS_InitializeInputFromSearchPath(&SDDSin, ztransverse->inputFile) || !SDDS_ReadPage(&SDDSin)) {
fprintf(stdout, "unable to read file %s\n", ztransverse->inputFile);
fflush(stdout);
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exitElegant(1);
}
if ((n_spect=SDDS_RowCount(&SDDSin))<4) {
fprintf(stdout, "too little data in %s\n", ztransverse->inputFile);
fflush(stdout);
exitElegant(1);
}
if (!power_of_2(n_spect-1))
bombElegant("number of spectrum points must be 2^n+1, n>1 (ZTRANSVERSE)", NULL);
ZReal[0] = getTransverseImpedance(&SDDSin, ztransverse->ZxReal);
ZImag[0] = getTransverseImpedance(&SDDSin, ztransverse->ZxImag);
ZReal[1] = getTransverseImpedance(&SDDSin, ztransverse->ZyReal);
ZImag[1] = getTransverseImpedance(&SDDSin, ztransverse->ZyImag);
if (!(freqData=SDDS_GetColumnInDoubles(&SDDSin, ztransverse->freqColumn))) {
fprintf(stdout, "Unable to read column %s (ZTRANSVERSE)\n", ztransverse->freqColumn);
fflush(stdout);
exitElegant(1);
}
if (!checkPointSpacing(freqData, n_spect, 1e-6)) {
fprintf(stdout, "Frequency values are not equispaced (ZTRANSVERSE)\n");
fflush(stdout);
exitElegant(1);
}
if ((df_spect = (freqData[n_spect-1]-freqData[0])/(n_spect-1))<=0) {
fprintf(stdout, "Zero or negative frequency spacing in %s (ZTRANSVERSE)\n",
ztransverse->inputFile);
fflush(stdout);
exitElegant(1);
}
df = df_spect;
nfreq = n_spect;
ztransverse->n_bins = 2*(n_spect-1);
ztransverse->bin_size = 1.0/(ztransverse->n_bins*df_spect);
if (!SDDS_Terminate(&SDDSin)) {
fprintf(stdout, "Error closing data set %s\n",
ztransverse->inputFile);
fflush(stdout);
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
exitElegant(1);
}
if (!(ztransverse->iZ[0] =
calloc(sizeof(*ztransverse->iZ[0]), n_spect*2)) ||
!(ztransverse->iZ[1] =
calloc(sizeof(*ztransverse->iZ[1]), n_spect*2)))
bombElegant("memory allocation failure (ZTRANSVERSE)", NULL);
for (i=0; i<n_spect; i++) {
if (i==0) {
/* DC term */
ztransverse->iZ[0][i] = -ZImag[0][i];
ztransverse->iZ[1][i] = -ZImag[1][i];
} else if (i==n_spect-1 && ztransverse->n_bins%2==0) {
/* Nyquist term */
ztransverse->iZ[0][2*i-1] = -ZImag[0][i];
ztransverse->iZ[1][2*i-1] = -ZImag[1][i];
} else {
/* real part of iZ */
ztransverse->iZ[0][2*i-1] = -ZImag[0][i];
ztransverse->iZ[1][2*i-1] = -ZImag[1][i];
/* imaginary part of iZ */
ztransverse->iZ[0][2*i ] = ZReal[0][i];
ztransverse->iZ[1][2*i ] = ZReal[1][i];
}
}
free(ZReal[0]);
free(ZReal[1]);
free(ZImag[0]);
free(ZImag[1]);
}
#if (!USE_MPI)
/* Only the serial version will dump this part of output */
if (ztransverse->wakes) {
ztransverse->wakes = compose_filename(ztransverse->wakes, run->rootname);
if (ztransverse->broad_band)
SDDS_ElegantOutputSetup(&ztransverse->SDDS_wake, ztransverse->wakes, SDDS_BINARY,
1, "transverse wake",
run->runfile, run->lattice, wake_parameter, BB_WAKE_PARAMETERS,
wake_column, WAKE_COLUMNS, "set_up_ztransverse",
SDDS_EOS_NEWFILE|SDDS_EOS_COMPLETE);
else {
SDDS_ElegantOutputSetup(&ztransverse->SDDS_wake, ztransverse->wakes, SDDS_BINARY,
1, "transverse wake",
run->runfile, run->lattice, wake_parameter, NBB_WAKE_PARAMETERS,
wake_column, WAKE_COLUMNS, "set_up_ztransverse",
SDDS_EOS_NEWFILE|SDDS_EOS_COMPLETE);
}
ztransverse->SDDS_wake_initialized = 1;
}
#endif
if (ztransverse->highFrequencyCutoff0>0) {
applyLowPassFilterToImpedance(ztransverse->iZ[0], nfreq,
ztransverse->highFrequencyCutoff0,
ztransverse->highFrequencyCutoff1);
applyLowPassFilterToImpedance(ztransverse->iZ[1], nfreq,
ztransverse->highFrequencyCutoff0,
ztransverse->highFrequencyCutoff1);
}
#if 0
if (!ztransverse->initialized) {
FILE *fp;
fp = fopen_e("ztransverse.sdds", "w", 0);
fprintf(fp, "SDDS1\n&column name=f units=Hz type=double &end\n");
fprintf(fp, "&column name=ZReal type=double &end\n");
fprintf(fp, "&column name=ZImag type=double &end\n");
fprintf(fp, "&data mode=ascii no_row_counts=1 &end\n");
for (i=0; i<nfreq; i++)
fprintf(fp, "%21.15e %21.15e %21.15e\n",
i*df, ztransverse->iZ[0][2*i], i>0?-ztransverse->iZ[0][2*i-1]:0);
fclose(fp);
}
#endif
ztransverse->initialized = 1;
}
void error_setup(ERRORVAL *errcon, NAMELIST_TEXT *nltext, RUN *run_cond, LINE_LIST *beamline)
{
long i;
log_entry("error_setup");
/* reset namelist variables to defaults */
/*
clear_error_settings = 1;
summarize_error_settings = 0;
error_log = NULL;
*/
/* process namelist text */
set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS);
set_print_namelist_flags(0);
if (processNamelist(&error_control, nltext)==NAMELIST_ERROR)
bombElegant(NULL, NULL);
if (echoNamelists) print_namelist(stdout, &error_control);
if (summarize_error_settings) {
fprintf(stdout, "summary of random error settings: \n");
fflush(stdout);
if (errcon->no_errors_first_step)
fprintf(stdout, "No errors will be generated for the first step.\n");
fflush(stdout);
for (i=0; i<errcon->n_items; i++) {
switch (errcon->error_type[i]) {
case UNIFORM_ERRORS:
case GAUSSIAN_ERRORS:
fprintf(stdout, "%8s: %sadditive %s errors with amplitude %e %s and cutoff %e %s\n",
errcon->quan_name[i], (errcon->flags[i]&NONADDITIVE_ERRORS?"non-":""),
known_error_type[errcon->error_type[i]],
(errcon->flags[i]&FRACTIONAL_ERRORS?100:1)*errcon->error_level[i],
errcon->flags[i]&FRACTIONAL_ERRORS?"%":errcon->quan_unit[i],
errcon->error_cutoff[i], (errcon->flags[i]&POST_CORRECTION?"(post-correction)":""));
fflush(stdout);
break;
case PLUS_OR_MINUS_ERRORS:
fprintf(stdout, "%8s: %sadditive %s errors with amplitude %e\n",
errcon->quan_name[i],
(errcon->flags[i]&NONADDITIVE_ERRORS?"non-":""),
known_error_type[errcon->error_type[i]],
errcon->error_level[i]);
fflush(stdout);
break;
}
}
log_exit("error_setup");
return;
}
errcon->no_errors_first_step = no_errors_for_first_step;
compute_end_positions(beamline);
if (errcon->fp_log)
fclose(errcon->fp_log);
#if USE_MPI
if (isSlave)
error_log = NULL;
#endif
if (error_log) {
errcon->fp_log = fopen_e(compose_filename(error_log, run_cond->rootname), "w", 0);
fprintf(errcon->fp_log, "SDDS1\n");
fprintf(errcon->fp_log,
"&description text=\"Error log--input: %s lattice: %s\", contents=\"error log, elegant output\" &end\n",
run_cond->runfile, run_cond->lattice);
fprintf(errcon->fp_log, "&associate filename=\"%s\", path=\"%s\", contents=\"elegant input, parent\" &end\n",
run_cond->runfile, getenv("PWD"));
fprintf(errcon->fp_log, "&associate filename=\"%s\", path=\"%s\", contents=\"elegant lattice, parent\" &end\n",
run_cond->lattice, getenv("PWD"));
fprintf(errcon->fp_log, "¶meter name=Step, type=long, description=\"simulation step\" &end\n");
fprintf(errcon->fp_log, "¶meter name=When, type=string, description=\"phase of simulation when errors were asserted\" &end\n");
fprintf(errcon->fp_log, "&column name=ParameterValue, type=double, description=\"Perturbed value\" &end\n");
fprintf(errcon->fp_log, "&column name=ParameterError, type=double, description=\"Perturbation value\" &end\n");
fprintf(errcon->fp_log, "&column name=ElementParameter, type=string, description=\"Parameter name\" &end\n");
fprintf(errcon->fp_log, "&column name=ElementName, type=string, description=\"Element name\" &end\n");
fprintf(errcon->fp_log, "&column name=ElementOccurence, type=long, description=\"Element occurence\" &end\n");
fprintf(errcon->fp_log, "&column name=ElementType, type=string, description=\"Element type\" &end\n");
fprintf(errcon->fp_log, "&data mode=ascii, lines_per_row=1, no_row_counts=1 &end\n");
fflush(errcon->fp_log);
}
else
errcon->fp_log = NULL;
if (clear_error_settings) {
/* indicate that no error data has been asserted */
errcon->new_data_read = 0;
/* clean up the error control structure and flags on elements */
if (errcon->n_items)
set_element_flags(beamline, errcon->name, NULL, NULL, NULL, errcon->n_items, PARAMETERS_ARE_STATIC, 0, 1, 0);
errcon->n_items = 0;
}
fprintf(stdout, "\n*** Cleared error settings\n");
fflush(stdout);
log_exit("error_setup");
}
void run_rpn_load(NAMELIST_TEXT *nltext, RUN *run)
{
SDDS_DATASET SDDSin;
long code, foundPage, iColumn, matchRow, rows, iParameter;
int32_t columns, parameters;
char *parameterValue = NULL;
double *data, data1;
char **columnName, **matchColumnData, *memName = NULL;
char **parameterName;
/* process the namelist text */
set_namelist_processing_flags(STICKY_NAMELIST_DEFAULTS);
set_print_namelist_flags(0);
if (processNamelist(&rpn_load, nltext)==NAMELIST_ERROR)
bombElegant(NULL, NULL);
if (echoNamelists) print_namelist(stdout, &rpn_load);
if (match_column && strlen(match_column)) {
if (use_row!=-1) {
fprintf(stdout, "Error: you asked to match a column and also gave use_row.\n");
exitElegant(1);
}
if (!match_column_value || !strlen(match_column_value)) {
fprintf(stdout, "Error: you must give match_column_value with match_column\n");
exitElegant(1);
}
}
if (match_parameter && strlen(match_parameter)) {
if (use_page!=-1) {
fprintf(stdout, "Error: you asked to match a parameter and also gave use_page.\n");
exitElegant(1);
}
if (!match_parameter_value || !strlen(match_parameter_value)) {
fprintf(stdout, "Error: you must give match_parameter_value with match_parameter\n");
exitElegant(1);
}
}
if (!filename || !strlen(filename)) {
fprintf(stdout, "Error: no filename given for rpn_load.\n");
exitElegant(1);
}
filename = compose_filename(filename, run->rootname);
if (!SDDS_InitializeInputFromSearchPath(&SDDSin, filename)) {
fprintf(stdout, "Error: couldn't initialize SDDS input for %s\n",
filename);
exitElegant(1);
}
foundPage = 0;
while ((code=SDDS_ReadPage(&SDDSin))>0) {
if (use_page>0) {
if (code==use_page) {
foundPage = 1;
break;
}
continue;
}
if (match_parameter && strlen(match_parameter)) {
if (!(parameterValue=SDDS_GetParameterAsString(&SDDSin, match_parameter, NULL)))
SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors|SDDS_EXIT_PrintErrors);
if (!wild_match(parameterValue, match_parameter_value))
continue;
foundPage = 1;
break;
}
if (use_page==-1 && SDDS_CheckEndOfFile(&SDDSin)==1) {
foundPage = 1;
break;
}
}
if (!foundPage) {
fprintf(stdout, "Error: no appropriate page found\n");
exitElegant(1);
}
if (!load_parameters) {
if ((columnName = SDDS_GetColumnNames(&SDDSin, &columns))==NULL) {
fprintf(stdout, "Warning: No columns in file!\n");
return;
}
rows = SDDS_RowCount(&SDDSin);
matchRow = rows-1;
if (use_row!=-1) {
if (use_row>=rows) {
fprintf(stdout, "Error: number of rows in file (%ld) less than needed for use_row=%ld\n",
rows, use_row);
exitElegant(1);
}
matchRow = use_row;
}
if (match_column) {
if (SDDS_GetNamedColumnType(&SDDSin, match_column)!=SDDS_STRING) {
fprintf(stdout, "Error: column %s nonexistent or not string type.\n",
match_column);
exitElegant(1);
}
if (!(matchColumnData=SDDS_GetColumn(&SDDSin, match_column))) {
fprintf(stdout, "Error: unable to get data for column %s\n", match_column);
exitElegant(1);
}
if (matching_row_number<0) {
/* use last match */
for (matchRow=rows-1; matchRow>=0; matchRow--)
if (wild_match(matchColumnData[matchRow], match_column_value))
break;
} else {
/* use nth match */
for (matchRow=0; matchRow<rows; matchRow++)
if (wild_match(matchColumnData[matchRow], match_column_value) &&
matching_row_number-- == 0)
break;
}
if (matchRow<0 || matchRow>=rows) {
fprintf(stdout, "Error: unable to find match for %s in column %s\n",
match_column_value, match_column);
exitElegant(1);
}
SDDS_FreeStringArray(matchColumnData, rows);
}
for (iColumn=0; iColumn<columns; iColumn++) {
switch (SDDS_GetNamedColumnType(&SDDSin, columnName[iColumn])) {
case SDDS_CHARACTER:
case SDDS_STRING:
break;
default:
if (!(data=SDDS_GetColumnInDoubles(&SDDSin, columnName[iColumn]))) {
fprintf(stdout, "Error: unable to get data for column %s as numerical data.\n",
columnName[iColumn]);
exitElegant(1);
}
if (!(memName=SDDS_Realloc(memName, sizeof(*memName)*((tag?strlen(tag):0)+strlen(columnName[iColumn])+2)))) {
fprintf(stdout, "Memory allocation failure trying to create memory name for loaded data\n");
exitElegant(1);
}
if (tag && strlen(tag))
sprintf(memName, "%s.%s", tag, columnName[iColumn]);
else
sprintf(memName, "%s", columnName[iColumn]);
rpn_store(data[matchRow], NULL, rpn_create_mem(memName, 0));
fprintf(stdout, "%le --> %s\n", data[matchRow], memName);
free(columnName[iColumn]);
free(data);
}
}
if (memName)
free(memName);
if (columnName)
free(columnName);
} else {
/* load data from parameters */
if ((parameterName = SDDS_GetParameterNames(&SDDSin, ¶meters))==NULL) {
fprintf(stdout, "Warning: No parameters in file!\n");
return;
}
for (iParameter=0; iParameter<parameters; iParameter++) {
switch (SDDS_GetNamedParameterType(&SDDSin, parameterName[iParameter])) {
case SDDS_CHARACTER:
case SDDS_STRING:
break;
default:
if (!SDDS_GetParameterAsDouble(&SDDSin, parameterName[iParameter], &data1)) {
fprintf(stdout, "Error: unable to get data for parameter %s as numerical data.\n",
parameterName[iParameter]);
exitElegant(1);
}
if (!(memName=SDDS_Realloc(memName, sizeof(*memName)*((tag?strlen(tag):0)+strlen(parameterName[iParameter])+2)))) {
fprintf(stdout, "Memory allocation failure trying to create memory name for loaded data\n");
exitElegant(1);
}
if (tag && strlen(tag))
sprintf(memName, "%s.%s", tag, parameterName[iParameter]);
else
sprintf(memName, "%s", parameterName[iParameter]);
rpn_store(data1, NULL, rpn_create_mem(memName, 0));
fprintf(stdout, "%le --> %s\n", data1, memName);
free(parameterName[iParameter]);
}
}
if (memName)
free(memName);
if (parameterName)
free(parameterName);
}
}
