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); } }