static void print_internal(jackctl_internal_t * internal)
{
printf("\n-------------------------- \n");
printf("internal = %s\n", jackctl_internal_get_name(internal));
printf("-------------------------- \n");
print_parameters(jackctl_internal_get_parameters(internal));
}
static void print_driver(jackctl_driver_t * driver)
{
printf("\n--------------------------\n");
printf("driver = %s\n", jackctl_driver_get_name(driver));
printf("-------------------------- \n");
print_parameters(jackctl_driver_get_parameters(driver));
}
int main(int argc, char *argv[]) {
double params[NParams];
FILE *pipe;
load_parameters(argc,argv,params);
print_parameters(params);
init(params);
try {
run(params);
}
catch (COHO_ALLOC_ERROR e) {
switch (e) {
case COHO_INIT_ERROR: cerr << "Initialization error" << endl; break;
case COHO_NO_COHO: cerr << "Couldn't allocate individual" << endl; break;
case COHO_NO_NEW_GENERATION: cerr << "Couldn't allocate generation" << endl; break;
case COHO_NO_PARENTS: cerr << "Couldn't allocate parent set" << endl; break;
case COHO_NO_CHILD: cerr << "Couldn't allocate new child" << endl; break;
default:
cerr << "Unknown runtime error" << endl;
}
}
catch (...) {
cerr << "Unknown (non-integer) runtime error" << endl;
}
}
MC1p(const Par &par) : TSP(par) {
LOG << "# Read parameters" << std::endl;
read_par();
LOG << "# Set parameters" << std::endl;
#define JN_MCPSB_PAR_SET(a) par.set(PP_CAT(_mc_, a), PP_STRING3(PP_CAT(mc_, a)));
JN_MAP(JN_MCPSB_PAR_SET, JN_MC_PARS1, JN_MC_PARS2)
LOG << "# Print parameters" << std::endl;
print_parameters();
LOG << "# Read initial structure" << std::endl;
chain_read_model(_pred_chain, par.get("pdb"));
LOG << "# Set indices" << std::endl;
thread_local static std::map<char, int> m {{'A', 0}, {'U', 1}, {'G', 2}, {'C', 3}};
m_indices.resize(_seq.size());
for (int i = 0; i < _seq.size(); i++) {
m_indices[i] = m[_seq[i]];
}
LOG << "# Set 2D trees" << std::endl;
set_trees();
LOG << "# Set ranges" << std::endl;
set_ranges();
LOG << "# Print ranges" << std::endl;
print_ranges();
}
int main(int argc, char *argv[])
{
Files_t files;
Working_hours_t hours;
Appointment_t *arr;
node_t* node,*temp;
int size,num,i;
get_main_arguments(argc,argv,&hours,&files);
arr=getRequests(&files,&size);
print_parameters(&files,&hours);
write_appointments(arr,size,&files);
node=build_ll(arr,size,&hours);
temp=node;
#ifndef DEBUG_MODE
while(node!=NULL){
printf("hour=%d\n",node->hour);
node=node->next;
}
#endif
node=temp;
add_personal_data(node,&files);
node=temp;
delete_appointments(&node,&files);
write_accepted_app(node,&files);
free_list(node);
return 0;
}
int main(int argc , char *argv[])
{
int size;
Appointment_t *appo;
Working_hours_t hours;
Files_t files;
#ifdef DEBUG
printf("STARTED argc = %d %s \n",argc,argv[1]);
#endif
get_main_arguments(argc,argv,&hours,&files);
appo = getRequests(&files,&size);
#ifdef DEBUG
printf("allocated array's siz is %d \n",size);
#endif
write_appointments(appo,size,&files);
print_parameters(&files,&hours);
#ifdef DEBUG
printf("%s %s %s %s %s %s",files.records_file_n
,files.patients_file_n
,files.accepted_appo_file_n
,files.delete_file_n
,files.parameters_file_n
,files.readable_records_file_n);
#endif
return 0;
}
static void print_dbg(
gtransp_dbg ths
)
{
print_parameters(
ths->N0, ths->N1, ths->hm, ths->blk0, ths->blk1, ths->in, ths->out,
ths->local_N0, ths->local_N0_start, ths->local_N1, ths->local_N1_start,
ths->comm, ths->fftw_flags);
}
LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
if(ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SINGLE_STEP) {
if((DWORD)ExceptionInfo->ExceptionRecord->ExceptionAddress == func_addr) {
PCONTEXT debug_context = ExceptionInfo->ContextRecord;
printf("Breakpoint hit!\n");
print_parameters(debug_context);
modify_text(debug_context);
debug_context->Eip = (DWORD)&change_text_stub;
return EXCEPTION_CONTINUE_EXECUTION;
}
}
return EXCEPTION_CONTINUE_SEARCH;
}
void RubyConfig::printConfiguration(ostream& out) {
out << "Ruby Configuration" << endl;
out << "------------------" << endl;
out << "protocol: " << CURRENT_PROTOCOL << endl;
SIMICS_print_version(out);
out << "compiled_at: " << __TIME__ << ", " << __DATE__ << endl;
out << "RUBY_DEBUG: " << bool_to_string(RUBY_DEBUG) << endl;
char buffer[100];
gethostname(buffer, 50);
out << "hostname: " << buffer << endl;
print_parameters(out);
}
int main(int argc, char* argv[])
{
Appointment_t* appointments; /*Array of records*/
int size; /*Number of records*/
/*Takes main arguments and change hours and file names*/
get_main_arguments(argc, argv, &hours, &files);
/*Reads records and writes into the array them*/
/*Size is a records number*/
appointments=getRequests(&files, &size);
/*Takes array of records and writes records into the file as xml file*/
write_appointments(appointments, size, &files);
/*Writes file names and hours into the file*/
print_parameters(&files, &hours);
return 0;
}
LONG WINAPI ExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
if(ExceptionInfo->ExceptionRecord->ExceptionCode == STATUS_GUARD_PAGE_VIOLATION) {
ExceptionInfo->ContextRecord->EFlags |= 0x100;
return EXCEPTION_CONTINUE_EXECUTION;
}
else if(ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SINGLE_STEP) {
if((DWORD)ExceptionInfo->ExceptionRecord->ExceptionAddress == (DWORD)func_addr) {
PCONTEXT debug_context = ExceptionInfo->ContextRecord;
printf("Breakpoint hit!\n");
print_parameters(debug_context);
modify_text(debug_context);
}
MEMORY_BASIC_INFORMATION mem_info;
DWORD old_protections = 0;
VirtualQuery((LPCVOID)func_addr, &mem_info, sizeof(MEMORY_BASIC_INFORMATION));
VirtualProtect(mem_info.BaseAddress, mem_info.RegionSize, mem_info.AllocationProtect | PAGE_GUARD,
&old_protections);
return EXCEPTION_CONTINUE_EXECUTION;
}
return EXCEPTION_CONTINUE_SEARCH;
}
int main(int argc, char *argv[])
{
int w, h;
char in[256], out[256];
if (argc < 3) {
usage(argv[0]);
return EXIT_FAILURE;
}
strncpy(in, argv[argc - 1], sizeof(in) - 1);
strncpy(out, argv[argc - 2], sizeof(out) - 1);
chk(get_parameters(¶meters, argc, (char **)(argv)));
print_parameters(¶meters);
chk(scene = scene_load(in));
w = scene->camera.image_width;
h = scene->camera.image_height;
chk(image = hdr_image_new(w, h));
context = ir_context_new(parameters.num_paths, parameters.max_path_length,
parameters.tmin, parameters.dist_clamp);
ir_distribute(context, scene);
chk(accumulate_mt(parameters.num_threads));
ir_render_vpls(context, image, scene, parameters.vpl_radius);
ir_context_delete(&context);
hdr_image_save(image, out);
scene_delete(&scene);
hdr_image_delete(&image);
return EXIT_SUCCESS;
error:
scene_delete(&scene);
hdr_image_delete(&image);
return 1;
}
void
ofm_read_simple(void)
{
if (ofm_on==TRUE) {
print_ofm_level(ofm_level-1);
print_font_dir(font_dir);
}
header = (char *) ofm+check_sum_pos;
retrieve_header();
print_family();
print_face();
print_coding_scheme();
print_design_size();
out("(COMMENT DESIGNSIZE IS IN POINTS)"); out_ln();
out("(COMMENT OTHER SIZES ARE MULTIPLES OF DESIGNSIZE)"); out_ln();
print_check_sum();
if ((seven_bit == TRUE) || (ofm_level != OFM_TFM))
print_seven_bit_safe_flag();
retrieve_parameters(ofm+(4*param_base));
print_parameters();
}
int main(int argc, char **argv)
{
ROS_INFO("Starting pid with node name %s", node_name.c_str());
// Initialize ROS stuff
ros::init(argc, argv, node_name); // Note node_name can be overidden by launch file
ros::NodeHandle node;
ros::NodeHandle node_priv("~");
while (ros::Time(0) == ros::Time::now())
{
ROS_INFO("controller spinning waiting for time to become non-zero");
sleep(1);
}
// Get params if specified in launch file or as params on command-line, set defaults
node_priv.param<double>("Kp", Kp, 1.0);
node_priv.param<double>("Ki", Ki, 0.0);
node_priv.param<double>("Kd", Kd, 0.0);
node_priv.param<double>("upper_limit", upper_limit, 1000.0);
node_priv.param<double>("lower_limit", lower_limit, -1000.0);
node_priv.param<double>("windup_limit", windup_limit, 1000.0);
node_priv.param<double>("cutoff_frequency", cutoff_frequency, -1.0);
node_priv.param<std::string>("topic_from_controller", topic_from_controller, "control_effort");
node_priv.param<std::string>("topic_from_plant", topic_from_plant, "rpms");
node_priv.param<std::string>("setpoint_topic", setpoint_topic, "setpoint");
node_priv.param<double>("max_loop_frequency", max_loop_frequency, 1.0);
node_priv.param<double>("min_loop_frequency", min_loop_frequency, 1000.0);
// Update params if specified as command-line options, & print settings
print_parameters();
if (not validate_parameters())
{
std::cout << "Error: invalid parameter\n";
}
// instantiate publishers & subscribers
control_effort_pub = node.advertise<std_msgs::Float64>(topic_from_controller, 1);
ros::Subscriber sub = node.subscribe(topic_from_plant, 1, plant_state_callback );
// COmment for now not to have changes. We want constant rpms
//ros::Subscriber setpoint_sub = node.subscribe(setpoint_topic, 1, setpoint_callback );
ros::Subscriber pid_enabled_sub = node.subscribe("pid_enable", 1, pid_enable_callback );
/* // configure dynamic reconfiguration
dynamic_reconfigure::Server<pid::PidConfig> config_server;
dynamic_reconfigure::Server<pid::PidConfig>::CallbackType f;
f = boost::bind(&reconfigure_callback, _1, _2);
config_server.setCallback(f);
*/
/*
// initialize diagnostics
diags = new PidControllerDiags;
diag_status.level = diagnostic_msgs::DiagnosticStatus::OK;
diag_status.message = "PID status nominal";
diags->diag_updater.setHardwareID(node_name);
diags->diag_updater.add(diags->freq_status);
diags->diag_updater.add("PID status", get_pid_diag_status);
*/
// Respond to inputs until shut down
ros::spin();
return 0;
}
/* parse programm line arguments, set-up parameter, initialise and run the simulation */
int main(int argc, const char* argv[])
{
int ret = 0;
double energy_keV, distance1_m, f_m, distance2_m;
struct parameters parameters;
//argument structures for funtions and field memory allocation
struct s2c s2c; s2c.field = malloc(sizeof(struct field));
struct insidecrl insidecrl; insidecrl.field = malloc(sizeof(struct field));
struct c2f c2f; c2f.field = malloc(sizeof(struct field));
int tag = tag_val; //tag determines whether initially create field or read from file
int current=0; //int used to keep track of the step the simulation goes through (identifying propagation)
double distance; //distance to perform fourier propagation
char fnameread[20]; //name of the file to be read
char fnamewrite[20]; //name of the file to wite to
if (argc != 5)
{
fprintf(stderr, "usage: %s <energy/keV> <distance1/m> <f/m> <distance2/m>\n", argv[0]);
ret = -1;
goto cleanup;
}
energy_keV = atof(argv[1]); /* energy in keV */
distance1_m = atof(argv[2]); /* distance from point-source to crl device in m */
f_m = atof(argv[3]); /* focal distance of individual lens in m */
distance2_m = atof(argv[4]); /* distance from crl device to detector in m */
parameters.xray.energy = energy_keV;
parameters.xray.wavelength = 12.398/energy_keV*1e-10; /* conversion factor from keV to angstrom to metre */
parameters.xray.wavenumber = 2*M_PI / parameters.xray.wavelength;
parameters.source.distance = distance1_m;
parameters.crl.f = f_m;
parameters.crl.aperture = 1e-3; /* 1 mm */
parameters.crl.separation = 10e-6; /* 10 µm */
parameters.crl.number = lenses;
parameters.crl.deltafactor = 3.53e-6;
parameters.crl.R = f_m*2.*M_PI*parameters.crl.deltafactor;
parameters.detector.distance = distance2_m;// (40/39 is q for s=40 and f=1);
parameters.detector.number = 1; //to be defined by field propagation
parameters.detector.width = 1; //to be defined by field propagation
// print_parameters(¶meters, stdout);
/* If noread then copy parameters to s2c and generate field*/
if (tag==-1){
copy_xray(¶meters.xray, &s2c.xray);
copy_source(¶meters.source, &s2c.source);
source_to_crl(&s2c, parameters.crl.aperture);
//// printf("FIRST STEP: Create field tag=%d \n", tag);
if (padf) pad_field(s2c.field);
write_field_to_file(s2c.field, "entrance_plane.txt", parameters.crl.aperture);
}
/* copy parameters to insidecrl structure*/
copy_xray(¶meters.xray, &insidecrl.xray);
copy_crl(¶meters.crl, &insidecrl.crl);
/* copy parameters to c2f structure for the propagation*/
copy_xray(&insidecrl.xray, &c2f.xray);
copy_crl(¶meters.crl, &c2f.crl);
copy_detector(¶meters.detector,&c2f.detector);
//Pre-process: Create/read field and allocate memory. Starting point will be after the lens
//if field is coming from entrance_plane (both generated or read) allocate and execute PREVIOUS phase-shifting
if (tag>0){
sprintf(fnameread,"crl_plane");
sprintf(fnameread,"%s%d.txt", fnameread, tag);
read_field_from_file(insidecrl.field, fnameread);
tag=-1;//CHANGE (fourier propagation)
}
//Get entrance plane field
else{
if (tag==-1){
//Getting from field already generated
insidecrl.field->size = malloc(s2c.field->dimensions*sizeof(int));
insidecrl.field->values = malloc(s2c.field->components*sizeof(complex double));
copy_field(s2c.field, insidecrl.field);
}
//Reading from entrance_plane
else if (tag==0){
sprintf(fnameread,"entrance_plane");
sprintf(fnameread,"%s.txt", fnameread);
read_field_from_file(insidecrl.field, fnameread);
tag=-1;
}
//// printf("CRL STEP: Apply phase-shift tag=%d \n", tag);
sprintf(fnamewrite,"crl_plane");
sprintf(fnamewrite,"%s1.txt", fnamewrite);
crl_inside(&insidecrl, fnamewrite);
}
//Once N is set, get detector parameters
parameters.detector.number=pix_num; //previously parameters.detector.number=insidecrl.field->components;
// parameters.detector.width=parameters.detector.number*c2f.xray.wavelength*c2f.detector.distance/parameters.crl.aperture;
parameters.detector.width=0.01;
parameters.detector.intensity = malloc(parameters.detector.number * sizeof(double));
copy_detector(¶meters.detector,&c2f.detector);
print_parameters(¶meters, stderr);
// Start lens loop: while current state (lens) has not reached total lens amount. (phshift) + /PROP+(PHSHIFT)/
// (previous) +/LOOP+(post)/
while(current!=lenses){
//// printf("NEW STEP: current state=%d , tag=%d \n", current, tag);
// get field from previous steps, allocate if first time
if (current==0){
c2f.field->size = malloc(insidecrl.field->dimensions*sizeof(int));
c2f.field->values = malloc(insidecrl.field->components*sizeof(complex double));
}
copy_field(insidecrl.field, c2f.field);
//RUN //perform fourier propagation: from CRL to CRL or Detector (different methods)
//// printf("Call propagation... \n");
if (current==(lenses-1)){
distance=parameters.detector.distance;
// get_spherical(&c2f, tag, distance);
if (padf) pad_field(c2f.field);
if (ray_add) ray_addition(&c2f, tag, distance);
else crl_to_focus(&c2f, tag, distance);
}
else{
distance=parameters.crl.separation;
crl_to_fourier(&c2f, tag, distance);
}
//// printf("distance for propagation %d was %f \n", current, distance);
//// printf("propagation successfully done. \n");
copy_field(c2f.field, insidecrl.field);
//if not reached detector then phase-shift before propagation
if (current!=(lenses-1)){
sprintf(fnamewrite,"crl_plane");
sprintf(fnamewrite,"%s%d.txt", fnamewrite, current+2);
crl_inside(&insidecrl, fnamewrite);
}
current=current+1;
}
write_field_to_file(c2f.field, "det_plane.txt", parameters.detector.width);
/* call gnuplot script to generate plots */
system ("gnuplot gpscript.gp");
cleanup:
if (parameters.detector.intensity) free(parameters.detector.intensity); parameters.detector.intensity=NULL;
return ret;
}//main
static void render(void)
{
double t = al_get_time();
if (regenerate) {
al_destroy_bitmap(logo);
al_destroy_bitmap(logo_flash);
logo = NULL;
regenerate = false;
}
if (!logo) {
/* Generate a new logo. */
ALLEGRO_BITMAP *fullflash;
ALLEGRO_BITMAP *fulllogo = generate_logo(param_values[0],
param_values[1],
strtol(param_values[2], NULL, 10),
strtod(param_values[3], NULL),
strtod(param_values[4], NULL),
strtod(param_values[5], NULL),
strtod(param_values[6], NULL),
strtod(param_values[7], NULL),
strtod(param_values[8], NULL),
&fullflash);
ALLEGRO_BITMAP *crop;
int x, y, left = 640, top = 480, right = -1, bottom = -1;
/* Crop out the non-transparent part. */
al_lock_bitmap(fulllogo, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY);
for (y = 0; y < 480; y++) {
for (x = 0; x < 640; x++) {
ALLEGRO_COLOR c = al_get_pixel(fulllogo, x, y);
float r, g, b, a;
al_unmap_rgba_f(c, &r, &g, &b, &a);
if (a > 0) {
if (x < left)
left = x;
if (y < top)
top = y;
if (x > right)
right = x;
if (y > bottom)
bottom = y;
}
}
}
al_unlock_bitmap(fulllogo);
if (right < left)
right = left;
if (bottom < top)
bottom = top;
crop = al_create_sub_bitmap(fulllogo, left, top,
1 + right - left, 1 + bottom - top);
logo = al_clone_bitmap(crop);
al_destroy_bitmap(crop);
al_destroy_bitmap(fulllogo);
crop = al_create_sub_bitmap(fullflash, left, top,
1 + right - left, 1 + bottom - top);
logo_flash = al_clone_bitmap(crop);
al_destroy_bitmap(crop);
al_destroy_bitmap(fullflash);
logo_x = left;
logo_y = top;
anim = t;
}
draw_background();
/* For half a second, display our flash animation. */
if (t - anim < 0.5) {
ALLEGRO_STATE state;
int w, h, i, j;
float f = sin(ALLEGRO_PI * ((t - anim) / 0.5));
ALLEGRO_COLOR c = al_map_rgb_f(f * 0.3, f * 0.3, f * 0.3);
w = al_get_bitmap_width(logo);
h = al_get_bitmap_height(logo);
al_store_state(&state, ALLEGRO_STATE_BLENDER);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
al_draw_tinted_bitmap(logo, al_map_rgba_f(1, 1, 1, 1 - f), logo_x, logo_y, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE);
for (j = -2; j <= 2; j += 2) {
for (i = -2; i <= 2; i += 2) {
al_draw_tinted_bitmap(logo_flash, c, logo_x + i, logo_y + j, 0);
}
}
al_restore_state(&state);
}
else
al_draw_bitmap(logo, logo_x, logo_y, 0);
print_parameters();
}
int main (int argc, char* argv[]) {
char filename1[200];
char filename2[200];
char pairs_file[200];
char fileout[200];
FILE* query_fp = 0;
FILE* reference_fp = 0;
FILE* fp_pairs = 0;
FILE* fpout = stdout;
int total_pairs = 0;
pair_struct* pairs = 0;
extern FILE *scaninfo_file;
setup_match_types();
/* Set Default Parameter Values*/
length_5p_for_weighting = 8; /* The 5' sequence length to be weighted except for the last residue */
scale = 4.0; /* The 5' miRNA scaling parameter */
strict = 0; /* Strict seed model on/off*/
debug = 0; /* Debugging mode on/off*/
key_value_pairs = 0;
gap_open = -9.0; /* Gap-open Penalty*/
gap_extend = -4.0; /* Gap-extend Penalty*/
score_threshold = 140.0; /* SW Score Threshold for reporting hits*/
score_ceiling = 0; /* Default upper limit to score. If zero, this is not used. */
energy_threshold = 1.0; /* Energy Threshold (DG) for reporting hits*/
verbosity = 1; /* Verbose mode on/off*/
brief_output = 0; /* Brief output off by default */
rusage_output = 0; /* rusage output off by default */
outfile = 0; /* Dump to file on/off*/
truncated = 0; /* Truncate sequences on/off*/
no_energy = 1; /* Turn off Energy Calcs - FASTER*/
restricted = 0; /* Perform restricted search space*/
parse_command_line(argc, argv, filename1, filename2, fileout, pairs_file);
if (gap_open > 0.0 || gap_extend > 0.0) {
fprintf(stderr, "Error: gap penalties may not be greater than 0\n");
return 1;
}
if (truncated < 0) {
fprintf(stderr, "Error: negative value give for UTR truncation\n");
return 1;
}
if ((query_fp = fopen(filename1, "r")) == NULL) {
fprintf(stderr, "Error: Cannot open file %s\n", filename1);
return 1;
}
if ((reference_fp = fopen(filename2, "r")) == NULL) {
fprintf(stderr, "Error: Cannot open file %s\n", filename2);
return 1;
}
fclose(reference_fp);
if ((outfile) && ((fpout = fopen(fileout, "w")) == NULL)) {
fprintf(stderr, "Error: Cannot create output file %s\n", fileout);
return 1;
}
if (restricted) {
if ((fp_pairs = fopen(pairs_file, "r")) == NULL) {
fprintf(stderr, "Error: Cannot open restrict pairs file %s\n", pairs_file);
return 1;
}
/* Initialize the pairs list for restriced searches*/
total_pairs = load_pairs(fp_pairs, &pairs);
fclose(fp_pairs);
}
fflush(fpout);
initialize_globals();
if(!brief_output)
print_parameters(filename1, filename2, fpout);
if (restricted && verbosity) {
printf("Performing Restricted Scan on:%d pairs\n", total_pairs);
}
find_targets(query_fp, fpout, pairs, total_pairs, filename2);
#ifdef USE_RUSAGE
if(rusage_output)
{
struct rusage ru;
if(getrusage(RUSAGE_SELF,&ru) != 0)
{
fprintf(stderr,"Could not get rusage data\n");
if(errno)
fprintf(stderr,"Reason: %s",strerror(errno));
}
else
{
printf("User CPU time: %ld.%06ld\n",ru.ru_utime.tv_sec,ru.ru_utime.tv_usec);
printf("Max RSS: %ld KB\n",ru.ru_maxrss);
}
}
#endif // RUSAGE
destroy_globals();
if (outfile) fclose(fpout);
if (scaninfo_file != stdout && scaninfo_file != stderr && scaninfo_file != NULL)
fclose(scaninfo_file);
json_close();
fclose(query_fp);
return 0;
}
/*
* Main function
*/
int main(int argc, char** argv)
{
struct timespec start, stop;
int next_option, verbose, write;
const char* const short_options = "hvn:g:o:s:i:";
char *giIndex = NULL;
char *includeIndex = NULL;
char *skipIndex = NULL;
clock_gettime(CLOCK_MONOTONIC, &start);
program_name = argv[0];
const struct option long_options[] = {
{ "help", 0, NULL, 'h'},
{ "verbose", 0, NULL, 'v'},
{ "nt", 1, NULL, 'n'},
{ "gi", 1, NULL, 'g'},
{ "nodes", 1, NULL, 'o'},
{ "skip", 1, NULL, 's'},
{ "include", 1, NULL, 'i'},
{ "dbSize", 1, NULL, 'd'},
{ NULL, 0, NULL, 0} /* Required at end of array. */
};
write = verbose = 0;
nt = gi = nodes = skip = include = NULL;
do {
next_option = getopt_long(argc, argv, short_options, long_options, NULL);
switch (next_option) {
case 'h':
print_usage(stdout, 0);
case 'v':
verbose = 1;
break;
case 'n':
nt = (char *) malloc(sizeof (char) * (strlen(optarg) + 1));
strcpy(nt, optarg);
break;
case 'g':
gi = (char *) malloc(sizeof (char) * (strlen(optarg) + 1));
strcpy(gi, optarg);
break;
case 'o':
nodes = (char *) malloc(sizeof (char) * (strlen(optarg) + 1));
strcpy(nodes, optarg);
break;
case 's':
skip = (char *) malloc(sizeof (char) * (strlen(optarg) + 1));
strcpy(skip, optarg);
break;
case 'i':
include = (char *) malloc(sizeof (char) * (strlen(optarg) + 1));
strcpy(include, optarg);
break;
case 'd':
MaxGb = atoi(optarg);
break;
}
} while (next_option != -1);
InputCheck(nt, gi, nodes, skip, include);
if(verbose == 1)
print_parameters();
if(verbose == 1)
printf("Getting biggest GI id from %s\n", gi);
GetMaxGiNuclDmp(gi);
if(verbose == 1)
printf("Importing GI and taxon ID pairs into memory from %s\n", gi);
ImportGiNuclDmp(gi);
if(verbose == 1)
printf("Getting biggest taxon ID from %s\n", nodes);
GetMaxNodeslDmp(nodes);
if(verbose == 1)
printf("Importing taxon parent and child IDs into memory from %s\n", nodes);
ImportNodeslDmp(nodes);
if(include != NULL) {
if(verbose == 1)
printf("Importing include taxon IDs from %s\n", include);
ImportInclude(include);
}
if(skip != NULL) {
if(verbose == 1)
printf("Importing exclude taxon IDs from %s\n", skip);
ImportExclude(skip);
}
if(verbose == 1)
printf("Reading and parsing fasta file %s\n", nt);
ReadFasta(nt);
if (nt) free(nt);
if (gi) free(gi);
if (nodes) free(nodes);
if (skip) free(skip);
if (include) free(include);
FreeIncludeExclude();
FreeGiId();
FreeTaxons();
clock_gettime(CLOCK_MONOTONIC, &stop);
printf("\n\tThe total time was %lu sec\n\n", timespecDiff(&stop, &start) / 1000000000);
return 0;
}
int main (int argc, char ** argv)
{
int i;
/*
* this is set to either euler or runge_kutta_4
*/
enum solver_t solver;
/*
* bc (boundary condition) can be either periodic or no_slip
*/
enum bc_t bc;
/*
* these specify the geometry of the area to be simulated
* tdim ist the total number of points, i.e. tdim = xdim *ydim
*/
int xdim, ydim, tdim;
double dx, dy;
/*
* this holds the neighbors
*/
int **neighbors;
/*
* this holds latitude and longitude values of each point
*/
unsigned int *lat, *lon;
/*
* this holds order of the data to be printed out
*/
unsigned int *print_out_order;
/*
* these control temporal aspects of the simulation
*/
long int ncycle;
double dt = 5.1;
long int n_iter = 25800;
int write_out_interval = 5000;
/*
* these hold the physical parameters
*
* f0: coriolis parameter (1/1sec)
* beta: linear beta for coriolis force (1/(meter sec))
* forcingTerm: Wind stress amplitude "tau_0"(N/meter^2)
* dissipationTerm: "A" viscosity coefficient (meters^2/sec)
* RayleighFriction: Rayleigh friction parameter (1/sec)
*/
double f0 = 5.0e-5;
double beta =2e-11;
double forcingTerm = 0.0005;
double dissipationTerm = 0.00005;
double RayleighFriction = 5e-8;
/*
* upper layer equilibrium depth (meters)
*/
double EquilibriumDepth = 50000.0;
double A;
/*
* this holds the physical parameters and the forcing
*/
double *parameters;
double *x_forcing, *y_forcing, *z_forcing;
/*
* "fields" holds the values of the u, v and P fields
*/
double *fields;
double *u, *v, *P;
/*
* "fields_prev" holds the u, v and P values of the previous time step
*/
//double *fields_prev;
//double *u_prev, *v_prev, *P_prev;
/*
* these are temporary storage locations
* for the Runge-Kutta scheme
*/
double *temp_dots_rk;
double *temp_fields_rk;
/*
* read parameters from command line
*/
if(argc == 2){
get_parameters(argv[1], &xdim, &ydim, &dx, &dy, &n_iter, &dt, &write_out_interval, &bc, &solver, &f0, &beta, &forcingTerm, &dissipationTerm, &RayleighFriction, &EquilibriumDepth, &A);
}
else{
fprintf(stderr, "ERROR: You need to give a file containing the parameters as an argument!\n");
exit(1);
}
print_parameters(xdim, ydim, dx, dy, n_iter, dt, write_out_interval, bc, solver, f0, beta, forcingTerm, dissipationTerm, RayleighFriction, EquilibriumDepth, A);
tdim = xdim*ydim;
/*
* allocate arrays containing geometrical information and fill these
*/
lat = calloc(tdim, sizeof(unsigned int));
lon = calloc(tdim, sizeof(unsigned int));
print_out_order = calloc(tdim, sizeof(unsigned int));
neighbors = calloc(tdim, sizeof(int*));
for(i=0; i< tdim; i++){
neighbors[i] = calloc(4, sizeof(int));
}
initialize_geometry(xdim, ydim, neighbors, lat, lon, print_out_order);
/*
* allocate memory for physical parameters and forcing
*/
parameters = calloc(5+3*tdim, sizeof(double));
parameters[0] = f0;
parameters[1] = beta;
parameters[2] = forcingTerm;
parameters[3] = dissipationTerm;
parameters[4] = RayleighFriction;
x_forcing = parameters + 5;
y_forcing = parameters + 5 + tdim;
z_forcing = parameters + 5 + 2*tdim;
/*
* allocate "fields" and set addresses for u, v, and P
*/
fields = calloc(3*tdim, sizeof(double));
u = fields;
v = fields + tdim;
P = fields + 2 * tdim;
/*
* allocate "fields_prev" and set addresses for u_prev, v_prev, and P_prev
*/
//fields_prev = calloc(3*tdim, sizeof(double));
//u_prev = fields_prev;
//v_prev = fields_prev + tdim;
//P_prev = fields_prev + 2 * tdim;
double *fields_dot;
fields_dot = calloc(3*tdim, sizeof(double));
/*
* allocate memory for temporary Runge-Kutta storage locations
*/
temp_dots_rk = calloc(3*tdim, sizeof(double));
temp_fields_rk = calloc(3*tdim, sizeof(double));
/*
* initialize fields
*/
initialize_fields (u, v, P, x_forcing, y_forcing, z_forcing, xdim, ydim, dx, dy, EquilibriumDepth, A, neighbors, lat, lon, bc);
/*
* loop through time steps to do the actual simulation
*/
for (ncycle=0; ncycle<n_iter; ncycle++) {
//printf("step #%li\n", ncycle);
/*
* print result
*/
if(ncycle % write_out_interval == 0){
print_field(u, "u", ncycle, xdim, ydim, print_out_order);
print_field(v, "v", ncycle, xdim, ydim, print_out_order);
print_field(P, "P", ncycle, xdim, ydim, print_out_order);
printf("%li ", ncycle);
fflush(stdout);
}
Fcalc(fields_dot, fields, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
//for (i=0;i<3*tdim;i++) {
// fields_prev[i] = fields[i];
//}
if(solver == runge_kutta_4){
/*
* Runge-Kutta 4th order
*
* dt
* y_1 = y_0 + ---- (y'_0 + 2 * y'_A + 2 * y'_B +y'_C)
* 6
*/
/* dt
* first step: y_A = y_0 + ---- y'_0
* 2
*/
for (i=0; i < 3*tdim; i++) {
temp_fields_rk[i] = fields[i]+0.5*dt*fields_dot[i];
}
Fcalc(temp_dots_rk, temp_fields_rk, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
for (i=0; i < 3*tdim; i++) {
fields_dot[i] += 2*temp_dots_rk[i];
}
/* dt
* second step: y_B = y_0 + ---- y'_A
* 2
*/
for (i=0; i < 3*tdim; i++) {
temp_fields_rk[i] = fields[i]+0.5*dt*temp_dots_rk[i];
}
Fcalc(temp_dots_rk, temp_fields_rk, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
for (i=0; i < 3*tdim; i++) {
fields_dot[i] += 2*temp_dots_rk[i];
}
/*
* third step: y_C = y_0 + dt * y'_B
*/
for (i=0; i < 3*tdim; i++){
temp_fields_rk[i] = fields[i]+dt*temp_dots_rk[i];
}
Fcalc(temp_dots_rk, temp_fields_rk, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
for (i=0; i < 3*tdim; i++) {
fields_dot[i] += temp_dots_rk[i];
}
/* dt
* final step: y_1 = y_0 + ---- (y'_0 + 2 * y'_A + 2 * y'_B +y'_C)
* 6
*/
for (i=0; i < 3*tdim; i++) {
fields_dot[i] /= 6.0;
fields[i] += dt*fields_dot[i];
}
}
else{
if(solver == euler){
/*
* the Euler scheme
*/
for (i=0; i < 3*tdim; i++) {
fields[i] += dt*fields_dot[i];
}
}
else{
fprintf(stderr, "ERROR: No valid solver was found\n");
exit(2);
}
}
}
printf("\n");
return(0);
}
void run(std::string tree_filename, std::string fasta_filename, std::string model_name) {
Model Mod; // The model
Counts data; // the counts
Parameters Par; // the parameters
std::vector<double> br; // branch lengths
double eps = 1e-8; // The threshold for the EM algorithm.
Parameters Parsim; // used for simulating data.
std::vector<double> brsim; // branch lengths of simulated data.
std::vector<std::vector<double> > Cov; // Covariance matrix
std::vector<double> variances; // The variances
bool simulate;
bool nonident;
std::string parameters_filename;
std::string covariances_filename;
// initialize random number generator with time(0).
random_initialize();
parameters_filename = strip_extension(fasta_filename) + ".dat";
covariances_filename = strip_extension(fasta_filename) + ".cov";
// Creates the pointers to the model-specific functions.
Mod = create_model(model_name);
std::cout << "Model: " << Mod.name << std::endl;
// Reads the tree.
Tree T = read_tree(tree_filename);
// Prints the Tree
std::cout << "Tree:" << std::endl;
print_tree(T);
// Check for possible nonidentifiability issues.
nonident = nonident_warning(T);
// Initialize the parameters for simulation of K81 data for testing
Parsim = create_parameters(T);
if (fasta_filename == ":test") { // if fasta file is :test generate random data.
simulate = true;
// Warn
std::cout << "WARNING: Using simulated data " << std::endl << std::endl;
// Generate random parameters
random_parameters_length(T, Mod, Parsim);
// Simulate the data
data = random_fake_counts(T, 1000, Parsim);
// Prints branch-lengths for future check.
branch_lengths(Parsim, brsim);
std::cout << "Simulated branch lengths:" << std::endl;
print_vector(brsim);
} else { // otherwise read the data
simulate = false;
// Read the counts.
std::cout << "Reading fasta file:" << std::endl;
read_counts(T, data, fasta_filename);
add_pseudocounts(0.01, data);
std::cout << std::endl;
}
// Check whether the data and the tree match.
if (T.nalpha != data.nalpha || T.nleaves != data.nspecies) {
throw std::invalid_argument("The order of the sequences or their number and the phylogenetic tree do not match.");
}
//Par = create_parameters(T);
//print_parameters(Par);
//print_vector(Par.r);
//clock_t
long start_time, end_time;
// Runs the EM algorithm. Par is used as initial parameters.
// After execution, Par contains the MLE computed by the algorithm.
// for local max over multiple iterations
Parameters Parmax = Par;
Model Modmax = Mod;
float likelL = 0.0;
float likelMax = -1000000.0;
float timerec;
float timemax;
int outfiles; //whether to save output
std::cout << "Starting the EM algorithm: " << std::endl;
int s;
int S = 0; //count of cases with neg branches
int iter;
int iterMax;
for (int it_runs = 0; it_runs < 10; it_runs++) {
Par = create_parameters(T);
Mod = create_model(model_name);
std::cout << it_runs << ", " ;
start_time = clock();
std::tie(likelL, iter) = EMalgorithm(T, Mod, Par, data, eps);
end_time = clock();
//print_parameters(Par);
// Choses the best permutation.
guess_permutation(T, Mod, Par);
branch_lengths(Par, br);
//print_vector(br);
s = find_negative(br);
S +=s;
timerec = ((float)end_time - start_time) / CLOCKS_PER_SEC;
//assign the 1st iter time value, inc ase it's the best
if (it_runs == 0){
timemax = timerec;
iterMax = iter;
}
if (likelL > likelMax){
Parmax = Par;
Modmax = Mod;
timemax = timerec;
likelMax = likelL;
iterMax = iter;
}
}
// If parameters are not identifiable, the computation of the covariance matrix will
// fail as the Fisher info matrix will not be invertible.
if (!nonident) {
// Compute the covariance matrix using observed Fisher.
full_MLE_observed_covariance_matrix(T, Modmax, Parmax, data, Cov);
variances.resize(Cov.size());
for(unsigned int i=0; i < Cov.size(); i++) {
variances[i] = Cov[i][i];
}
// OUTPUT Save the sigmas into a file
//save_sigmas_to(covariances_filename, Cov);
}
std::cout << std::endl;
std::cout << "Finished." << std::endl;
std::cout << "Likelihood: " << log_likelihood(T, Parmax, data) << std::endl ;
std::cout << "Time: " << timemax << std::endl << std::endl;
std::cout << "negative branches: " << S << std::endl;
std::cout << "Iter: " << iterMax << std::endl;
//std::cout << "Branch lengths: " << std::endl;
//print_vector(br);
outfiles = 0;
if (!nonident && outfiles) {
std::cout << "Parameter variances: " << std::endl;
print_vector(variances);
}
std::cout << "Newick Tree:" << std::endl;
print_newick_tree(T, br);
// if is a simulation, print the L2 distance !
if (simulate) {
std::cout << "L2 distance: " << parameters_distance(Par, Parsim) << std::endl;
std::cout << "KL divergence: " << KL_divergence(T, Par, Parsim) << std::endl;
std::cout << std::endl;
}
// if it is not a simulation, store the parameters in a file !
if (!simulate && outfiles) {
std::fstream st;
st.precision(15);
st.setf(std::ios::fixed,std::ios::floatfield);
st.open(parameters_filename.c_str(), std::ios::out);
print_parameters(Par, st);
}
}
int main(int argc, char *argv[])
{
jackctl_server_t * server;
const JSList * parameters;
const JSList * drivers;
const JSList * internals;
const JSList * node_ptr;
jackctl_sigmask_t * sigmask;
int opt, option_index;
const char* driver_name = "dummy";
const char* client_name = "audioadapter";
const char *options = "d:c:";
struct option long_options[] = {
{"driver", 1, 0, 'd'},
{"client", 1, 0, 'c'},
};
while ((opt = getopt_long (argc, argv, options, long_options, &option_index)) != EOF) {
switch (opt) {
case 'd':
driver_name = optarg;
break;
case 'c':
client_name = optarg;
break;
default:
usage();
exit(0);
}
}
server = jackctl_server_create(NULL, NULL);
parameters = jackctl_server_get_parameters(server);
/*
jackctl_parameter_t* param;
union jackctl_parameter_value value;
param = jackctl_get_parameter(parameters, "verbose");
if (param != NULL) {
value.b = true;
jackctl_parameter_set_value(param, &value);
}
*/
printf("\n========================== \n");
printf("List of server parameters \n");
printf("========================== \n");
print_parameters(parameters);
printf("\n========================== \n");
printf("List of drivers \n");
printf("========================== \n");
drivers = jackctl_server_get_drivers_list(server);
node_ptr = drivers;
while (node_ptr != NULL) {
print_driver((jackctl_driver_t *)node_ptr->data);
node_ptr = jack_slist_next(node_ptr);
}
printf("\n========================== \n");
printf("List of internal clients \n");
printf("========================== \n");
internals = jackctl_server_get_internals_list(server);
node_ptr = internals;
while (node_ptr != NULL) {
print_internal((jackctl_internal_t *)node_ptr->data);
node_ptr = jack_slist_next(node_ptr);
}
// No error checking in this simple example...
jackctl_server_open(server, jackctl_server_get_driver(server, driver_name));
jackctl_server_start(server);
jackctl_server_load_internal(server, jackctl_server_get_internal(server, client_name));
/*
// Switch master test
jackctl_driver_t* master;
usleep(5000000);
printf("jackctl_server_load_master\n");
master = jackctl_server_get_driver(server, "coreaudio");
jackctl_server_switch_master(server, master);
usleep(5000000);
printf("jackctl_server_load_master\n");
master = jackctl_server_get_driver(server, "dummy");
jackctl_server_switch_master(server, master);
*/
sigmask = jackctl_setup_signals(0);
jackctl_wait_signals(sigmask);
jackctl_server_stop(server);
jackctl_server_close(server);
jackctl_server_destroy(server);
return 0;
}
/** @brief Function for main application entry.
*/
int main(void)
{
radio_tests_t test = RADIO_TEST_NOP;
radio_tests_t cur_test = RADIO_TEST_NOP;
init();
uart_config(TX_PIN_NUMBER, RX_PIN_NUMBER);
uart_putstring((const uint8_t *)"RF Test\r\n");
NVIC_EnableIRQ(TIMER0_IRQn);
__enable_irq();
while (true)
{
__WFI();
switch (uart_get())
{
case 'a':
while (true)
{
uart_putstring((const uint8_t *)"Enter start channel \
(two decimal digits, 00 to 80):");
channel_start_ = get_dec2();
if (channel_start_ <= 80)
break;
uart_putstring((const uint8_t *)"Channel must be between 0 and 80\r\n");
}
test = cur_test;
break;
case 'b':
while (true)
{
uart_putstring((const uint8_t *)"Enter end channel \
(two decimal digits, 00 to 80):");
channel_end_ = get_dec2();
if (channel_end_ <= 80)
{
break;
}
uart_putstring((const uint8_t *)"Channel must be between 0 and 80\r\n");
}
test = cur_test;
break;
case 'c':
test = RADIO_TEST_TXCC;
break;
case 'd':
while (true)
{
uart_putstring((const uint8_t *)"Enter delay in ms \
(two decimal digits, 01 to 99):");
delayms_ = get_dec2();
if ((delayms_ > 0) && (delayms_ < 100))
{
break;
}
uart_putstring((const uint8_t *)"Delay must be between 1 and 99\r\n");
}
test = cur_test;
break;
case 'e':
radio_sweep_end();
cur_test = RADIO_TEST_NOP;
break;
case 'm':
get_datarate();
test = cur_test;
break;
case 'o':
test = RADIO_TEST_TXMC;
uart_putstring((const uint8_t *)"TX modulated carrier\r\n");
break;
case 'p':
get_power();
test = cur_test;
break;
case 'r':
test = RADIO_TEST_RXSWEEP;
uart_putstring((const uint8_t *)"RX Sweep\r\n");
break;
case 's':
print_parameters();
break;
case 't':
test = RADIO_TEST_TXSWEEP;
uart_putstring((const uint8_t *)"TX Sweep\r\n");
break;
case 'x':
test = RADIO_TEST_RXC;
uart_putstring((const uint8_t *)"RX constant carrier\r\n");
break;
case 'h':
// Fall through.
default:
help();
break;
}
switch (test)
{
case RADIO_TEST_TXCC:
if (sweep)
{
radio_sweep_end();
sweep = false;
}
radio_tx_carrier(txpower_, mode_, channel_start_);
cur_test = test;
test = RADIO_TEST_NOP;
break;
case RADIO_TEST_TXMC:
if (sweep)
{
radio_sweep_end();
sweep = false;
}
radio_modulated_tx_carrier(txpower_, mode_, channel_start_);
cur_test = test;
test = RADIO_TEST_NOP;
break;
case RADIO_TEST_TXSWEEP:
radio_tx_sweep_start(txpower_, mode_, channel_start_, channel_end_, delayms_);
sweep = true;
cur_test = test;
test = RADIO_TEST_NOP;
break;
case RADIO_TEST_RXC:
if (sweep)
{
radio_sweep_end();
sweep = false;
}
radio_rx_carrier(mode_, channel_start_);
cur_test = test;
test = RADIO_TEST_NOP;
break;
case RADIO_TEST_RXSWEEP:
radio_rx_sweep_start(mode_, channel_start_, channel_end_, delayms_);
sweep = true;
cur_test = test;
test = RADIO_TEST_NOP;
break;
case RADIO_TEST_NOP:
// Fall through.
default:
// No implementation needed.
break;
}
}
}
int main(int argc, char *argv[])
{
Parameters *parameters; // user defined parameters
Geometry *geometry; // homogenous cube geometry
Material *material; // problem material
Bank *source_bank; // array for particle source sites
Bank *fission_bank; // array for particle fission sites
Tally *tally; // scalar flux tally
double *keff; // effective multiplication factor
double t1, t2; // timers
// Get inputs: set parameters to default values, parse parameter file,
// override with any command line inputs, and print parameters
parameters = init_parameters();
parse_parameters(parameters);
read_CLI(argc, argv, parameters);
print_parameters(parameters);
// Set initial RNG seed
set_initial_seed(parameters->seed);
set_stream(STREAM_OTHER);
// Create files for writing results to
init_output(parameters);
// Set up geometry
geometry = init_geometry(parameters);
// Set up material
material = init_material(parameters);
// Set up tallies
tally = init_tally(parameters);
// Create source bank and initial source distribution
source_bank = init_source_bank(parameters, geometry);
// Create fission bank
fission_bank = init_fission_bank(parameters);
// Set up array for k effective
keff = calloc(parameters->n_active, sizeof(double));
center_print("SIMULATION", 79);
border_print();
printf("%-15s %-15s %-15s %-15s\n", "BATCH", "ENTROPY", "KEFF", "MEAN KEFF");
// Start time
t1 = timer();
run_eigenvalue(parameters, geometry, material, source_bank, fission_bank, tally, keff);
// Stop time
t2 = timer();
printf("Simulation time: %f secs\n", t2-t1);
// Free memory
free(keff);
free_tally(tally);
free_bank(fission_bank);
free_bank(source_bank);
free_material(material);
free(geometry);
free(parameters);
return 0;
}
int
main (int argc, const char *argv[])
{
unsigned int idx;
char *end;
int debug = 0;
/* sequence file name specified by the user, otherwise STDIN will be used */
const char *sequence_file_name = NULL;
const char *lists_file_name = NULL;
/* data structure for all k-mer lists used for masking */
unsigned int nlists = 0;
unsigned int nlist_parameters = 0;
unsigned int npos = 0;
unsigned int list_pos[MAX_VARIABLES], list_components[MAX_VARIABLES];
masker_parameters mp = {};
parameters_builder pbuilder = {};
input_sequence *input_seq = NULL;
pr_append_str parse_err;
pr_append_str warnings;
init_pr_append_str (&parse_err);
init_pr_append_str (&warnings);
/* fill mp with default parameters */
mp.mdir = DEFAULT_MASKING_DIRECTION;
mp.failure_rate = DEFAULT_FAILURE_RATE;
mp.abs_cutoff = DEFAULT_ABS_CUTOFF;
mp.nucl_masked_in_5p_direction = DEFAULT_M5P;
mp.nucl_masked_in_3p_direction = DEFAULT_M3P;
mp.print_sequence = PRINT_SEQUENCE;
mp.do_soft_masking = HARD_MASKING;
mp.masking_char = DEFAULT_MASK_CHAR;
mp.list_prefix = DEFAULT_LIST_FILE_PREFIX;
/* parsing and checking the commandline arguments */
for (idx = 1; (int)idx < argc; idx++) {
if (!strcmp (argv[idx], "-h") || !strcmp (argv[idx], "--help") || !strcmp (argv[idx], "-?")) {
print_help (0);
} else if ((int)idx == argc - 1 && argv[idx][0] != '-') {
sequence_file_name = argv[idx];
} else if (!strcmp (argv[idx], "-lf") || !strcmp (argv[idx], "--lists_file")) {
/* lists specified from the file */
if (!argv[idx + 1] || argv[idx + 1][0] == '-') {
pr_append_new_chunk_external (&warnings, "No lists file specified.");
idx += 1;
continue;
}
lists_file_name = argv[idx + 1];
idx += 1;
} else if (!strcmp (argv[idx], "-l") || !strcmp (argv[idx], "--list")) {
/* lists specified from the commandline */
if (nlist_parameters == MAX_VARIABLES) {
pr_append_new_chunk_external (&parse_err, "Maximum number of list variables reached.");
break;
}
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "No list name specified with -l parameter!.");
continue;
}
/* get the positions of list files */
list_pos[nlist_parameters] = idx;
while (argv[idx + 1]) {
if (argv[idx + 1][0] == '-') {
if (!argv[idx + 1][1]) break;
strtod (argv[idx + 1] + 1, &end);
if (*end != 0) break;
} else if (idx + 1 != list_pos[nlist_parameters] + 1 && idx + 1 != list_pos[nlist_parameters] + 4) {
strtod (argv[idx + 1], &end);
if (*end != 0) break;
} else if (idx + 1 == list_pos[nlist_parameters] + 4 && strcmp (argv[idx + 1], "sq")) {
break;
}
idx += 1;
}
list_components[nlist_parameters] = idx - list_pos[nlist_parameters];
nlist_parameters += 1;
npos += 1;
} else if (!strcmp (argv[idx], "-lp") || !strcmp (argv[idx], "--list_prefix")) {
/* lists specified by the prefix */
if (!argv[idx + 1] || argv[idx + 1][0] == '-') {
pr_append_new_chunk_external (&warnings, "No list prefix specified! Using the default value.");
idx += 1;
continue;
}
mp.list_prefix = (char *)argv[idx + 1];
idx += 1;
} else if (!strcmp (argv[idx], "-p") || !strcmp (argv[idx], "--probability_cutoff")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "No cutoff value specified! Using the default value.");
idx += 1;
continue;
}
mp.failure_rate = strtod (argv[idx + 1], &end);
mp.abs_cutoff = 0;
if (*end != 0 || mp.failure_rate < 0 || mp.failure_rate > 1) {
pr_append_new_chunk_external (&parse_err, "Invalid cutoff value: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-a") || !strcmp (argv[idx], "--absolute_value_cutoff")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "No absolute cutoff value specified! Using the default value.");
idx += 1;
continue;
}
mp.abs_cutoff = strtod (argv[idx + 1], &end);
mp.failure_rate = 0.0;
if (*end != 0 || mp.abs_cutoff < 0) {
pr_append_new_chunk_external (&parse_err, "Invalid absolute cutoff value: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-m5") || !strcmp (argv[idx], "--mask_5p")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "Number of nucleotides masked in 5' direction not specified! Using the default value.");
idx += 1;
continue;
}
mp.nucl_masked_in_5p_direction = strtod (argv[idx + 1], &end);
if (*end != 0) {
pr_append_new_chunk_external (&parse_err, "Invalid number of nucleotides masked in 5' direction: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-m3") || !strcmp (argv[idx], "--mask_3p")) {
if (!argv[idx + 1]) {
pr_append_new_chunk_external (&warnings, "Number of nucleotides masked in 3' direction not specified! Using the default value.");
idx += 1;
continue;
}
mp.nucl_masked_in_3p_direction = strtod (argv[idx + 1], &end);
if (*end != 0) {
pr_append_new_chunk_external (&parse_err, "Invalid number of nucleotides masked in 3' direction: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-c") || !strcmp (argv[idx], "--masking_char")) {
if (!argv[idx + 1 || argv[idx + 1][0] == '-']) {
pr_append_new_chunk_external (&warnings, "Character for masking not specified! Using the default value.");
idx += 1;
continue;
}
mp.masking_char = argv[idx + 1][0];
if (strlen(argv[idx + 1]) > 1 || mp.masking_char < 33 || mp.masking_char > 126) {
pr_append_new_chunk_external (&parse_err, "Invalid character for masking: ");
pr_append_external (&parse_err, argv[idx + 1]);
break;
}
idx += 1;
} else if (!strcmp (argv[idx], "-d") || !strcmp (argv[idx], "--masking_direction")) {
if (!argv[idx + 1] || argv[idx + 1][0] == '-') {
pr_append_new_chunk_external (&warnings, "Masking direction not specified! Masking both strands by default.");
} else if (!strcmp (argv[idx + 1], "both")) {
mp.mdir = both_on_same;
} else if (!strcmp (argv[idx + 1], "fwd")) {
mp.mdir = fwd;
} else if (!strcmp (argv[idx + 1], "rev")) {
mp.mdir = rev;
} else {
pr_append_new_chunk_external (&warnings, "Unknown masking direction: ");
pr_append_external (&warnings, argv[idx + 1]);
pr_append_external (&warnings, ". Masking both strands by default.");
}
idx += 1;
} else if (!strcmp (argv[idx], "-s") || !strcmp (argv[idx], "--soft_mask")) {
mp.do_soft_masking = SOFT_MASKING;
} else if (!strcmp (argv[idx], "-D")) {
debug += 1;
} else {
pr_append_new_chunk_external (&parse_err, "Unknown parameter: ");
pr_append_external (&parse_err, argv[idx]);
break;
}
}
input_seq = create_input_sequence_from_file_name (sequence_file_name, &parse_err);
if (parse_err.data != NULL) {
fprintf(stderr, "%s -> parsing commandline: ERROR: %s\n", pr_programme_name, parse_err.data);
exit(-1);
}
if (warnings.data != NULL) {
fprintf(stderr, "%s -> parsing commandline: WARNING: %s\n", pr_programme_name, warnings.data);
}
if (lists_file_name) {
/* if lists are given in a text file */
mp.fp = read_formula_parameters_from_file (lists_file_name, &nlist_parameters, &pbuilder, &mp.formula_intercept, &parse_err);
nlists = pbuilder.nfp;
}
if (npos != 0) {
/* if lists are given by commandline arguments (can be added to the ones given in a file) */
pbuilder.fp_array = mp.fp;
for (idx = 0; idx < npos; idx++) {
unsigned int pos = list_pos[idx] + 1;
char *values[4];
unsigned int nvalues = list_components[idx];
char *end;
memcpy (&values, &argv[pos], nvalues * sizeof(*argv));
if (nvalues == 1) {
double ic;
double neg = 1.0;
if (values[0][0] == '-') {
values[0] += 1;
neg = -1.0;
}
ic = strtod (values[0], &end);
if (*end == 0) {
mp.formula_intercept = ic * neg;
continue;
}
}
add_variable_to_formula_parameters (values, nvalues, &pbuilder, &parse_err);
}
nlists = pbuilder.nfp;
mp.fp = pbuilder.fp_array;
} else if (nlists == 0 && !lists_file_name) {
/* if there are no lists specified use the default formula */
mp.fp = create_default_formula_parameters (mp.list_prefix, &parse_err);
mp.formula_intercept = DEFAULT_INTERCEPT;
nlists = DEFAULT_NLISTS;
nlist_parameters = DEFAULT_NLIST_PARAMETERS;
}
mp.nlists = nlists;
if (mp.abs_cutoff > 0 && nlist_parameters != 1) {
fprintf (stderr, "Error: Absolute value cutoff works with one list and one k-mer frequency parameter only. Currently you are using %u lists and %u parameters.\n", nlists, nlist_parameters);
print_help(1);
}
if (parse_err.data != NULL) {
fprintf(stderr, "%s -> building formula: ERROR: %s\n", pr_programme_name, parse_err.data);
delete_input_sequence (input_seq);
exit(-1);
}
if (debug > 0) print_parameters (&mp);
read_and_mask_sequence (input_seq, NULL, &mp, &parse_err, debug);
if (parse_err.data != NULL) {
fprintf(stderr, "%s -> masking sequence: ERROR: %s\n", pr_programme_name, parse_err.data);
delete_input_sequence (input_seq);
delete_formula_parameters (mp.fp, nlists);
exit(-1);
}
destroy_pr_append_str_data (&warnings);
destroy_pr_append_str_data (&parse_err);
delete_input_sequence (input_seq);
delete_formula_parameters (mp.fp, nlists);
if (debug > 0) fprintf (stderr, "Done!\n");
return 0;
}
int main(int argc, char *argv[])
{
Parameters *parameters; // user defined parameters
Geometry *geometry; // homogenous cube geometry
Material *material; // problem material
Bank *source_bank; // array for particle source sites
Tally *tally; // scalar flux tally
double *keff; // effective multiplication factor
double t1, t2; // timers
#ifdef _OPENMP
unsigned long counter = 0; //counter to decide the start pos of master bank copy from sub banks
Bank *g_fission_bank; //global fission bank
#endif
// Get inputs: set parameters to default values, parse parameter file,
// override with any command line inputs, and print parameters
parameters = init_parameters();
parse_parameters(parameters);
read_CLI(argc, argv, parameters);
print_parameters(parameters);
// Set initial RNG seed
set_initial_seed(parameters->seed);
set_stream(STREAM_INIT);
// Create files for writing results to
init_output(parameters);
// Set up geometry
geometry = init_geometry(parameters);
// Set up material
material = init_material(parameters);
// Set up tallies
tally = init_tally(parameters);
// Create source bank and initial source distribution
source_bank = init_source_bank(parameters, geometry);
// Create fission bank
#ifdef _OPENMP
omp_set_num_threads(parameters->n_threads); // Set number of openmp threads
printf("threads num: %d\n", parameters->n_threads);
// Allocate one master fission bank
g_fission_bank = init_bank(2*parameters->n_particles);
#endif
// Set up array for k effective
keff = calloc(parameters->n_active, sizeof(double));
center_print("SIMULATION", 79);
border_print();
printf("%-15s %-15s %-15s\n", "BATCH", "KEFF", "MEAN KEFF");
#ifdef _OPENMP
// Start time
t1 = omp_get_wtime();
run_eigenvalue(counter, g_fission_bank, parameters, geometry, material, source_bank, fission_bank, tally, keff);
// Stop time
t2 = omp_get_wtime();
#endif
printf("Simulation time: %f secs\n", t2-t1);
// Free memory
#ifdef _OPENMP
free_bank(g_fission_bank);
#endif
free(keff);
free_tally(tally);
free_bank(source_bank);
free_material(material);
free(geometry);
free(parameters);
return 0;
}
int main(int argc, char *argv[])
{
char HFile[NCHARMAX],tabledir_aux[NCHARMAX],Tstr[NCHARMAX];
int first_time=0;
float pmin,pmax;
double tau_ini, x_medium;
double pos3d[3];
double s_nH,sx_cont,s_nd;
double sq_mu,sq_mu2,sq_b,sq_a,sq_arg;
double dust_fac = ext_zstar/zstar,P_H;
long ip,i,j,k;
const gsl_rng_type * T;
time_t t0,t1,t2,t4,tc1,tc2;
int NScatRec = 1e4;
long ilow,ihigh;
double x_1,x_0,H1,H0,xl,Hl,xlow,xhigh,rvp,vpl,vp0l,vp1l,ran0l,ran1l,vp0h,vp1h,ran0h,ran1h,vplow,vphigh;
float tot_tab,used_tab;
//
double Vth=sqrt(2*KB*Temp/MP);
int upcone;
c = 299792.482; // km s-1
Inv_c = 1./c;
Kth=Vth/(c*100000.0);
gsl_rng *r;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);
if(argc < 3)
{
printf(" Input parameter missing. \n ");
printf(" Usage: > LyaRt [ParFile] [SEED] \n Exiting...");
exit(0);
}
/* Paramter file is read, it defines most of the variables
found in allvars.h */
strcpy(ParFile,argv[1]);
Seed0 = atoi(argv[2]);
default_parameters();
dprints(OutShort);
dprints(OutLong);
read_parameters(ParFile);
dprints(OutShort);
dprints(OutLong);
// The following are definitions specific to particular geometries.
if (strcmp(GeomName,"Wind2")==0 || strcmp(GeomName,"Wind3")==0)
{
dr = (RSphere-R_inner) / (NCells-1);
NCellSphere = R_inner/dr + 1.0;
NCells += NCellSphere;
}
if (strcmp(GeomName,"Wind4")==0)
{
NCellSphere = 100;
dr = R_Static / (NCellSphere-1);
NCells = (long) ((RSphere - R_inner)/dr + 1.0);
NCells += NCellSphere+1;
if (NCells > 1e4)
printf("WARNING: NCells = %ld value too high\n",NCells);
}
if (strcmp(GeomName,"ThinShell2")==0)
{
NCellSphere = 500;
dr1 = R_inner / (NCellSphere-1);
dr2 = (RSphere-R_inner)/(NCells-1);
NCells+= NCellSphere;
}
// ---
P = (photon*) malloc(NPhotons * sizeof(photon));
CellArr = (cell*) malloc(NCells * sizeof(cell));
define_geometry(GeomName,CellArr);
gsl_rng_set(r,Seed0); //Initializing the random generator with seed Seed0?
//Finding range of emission probability in cells
pmin = CellArr[0].p_lya;
pmax = pmin;
for (i=1;i<NCells;i++)
{
if(CellArr[i].p_lya < pmin)
pmin = CellArr[i].p_lya;
if(CellArr[i].p_lya > pmax)
pmax = CellArr[i].p_lya;
}
strcpy(tabledir_aux,tabledir);
strcat(tabledir_aux,sxfile);
strcpy(HFile,tabledir_aux);
if (Temp >= 0)
sprintf(Tstr,"%.2f",Temp);
else
sprintf(Tstr,"%.1f",Temp);
if (Temp > 0 && Temp < 1)
sprintf(Tstr,"%.3f",Temp);
strcat(HFile,Tstr);
printf(" Storing tabulated data... \n");
HList = (double*) malloc(NTAB2*sizeof(double)*2);
DipList = (double*) malloc(NTAB1*2*sizeof(double));
HGList = (float*) malloc(NTAB2*2*sizeof(float));
#ifndef HAPPROX
get_H(HFile,HList);
printf("GET_H read\n");
#endif
get_dipolar(DipList);
printf("GET_DIPOLAR read\n");
get_HG(HGList);
printf("GET_HG read\n");
// Print parameters read
print_parameters(CellArr);
#ifdef TEST_RII
printf("TESTING REDISTRIBUTION FUNCTION for x0 = %f\n",x_test);
#endif
//Loop over NPhotons
printf(" Loop over %ld photons started...\n",NPhotons);
cx = 0.;
cy = 0.;
cz = 0.;
nu0 = 2.47e15;
gtype = (strcmp(GeomName,"HomSlab")==0) ? 0 : 1;
if (strcmp(GeomName,"HomSphere")==0) gtype = 2;
dprinti(gtype);
fflush(stdout);
nout = 0;
#ifdef TCONST
TPar = sx_const * pow(CellArr[0].T,-0.5);
#endif
XArr = (float *) malloc(NPhotons*sizeof(float));
X0Arr = (float *) malloc(NPhotons*sizeof(float));
InterArr = (int *) malloc(NPhotons*sizeof(int));
NscatArr = (int *) malloc(NPhotons*sizeof(int));
#ifdef GETPOSDIR
PosArr = (float *) malloc(NPhotons*3*sizeof(float));
AngleArr = (float *) malloc(NPhotons*2*sizeof(float));
PosArrLong = (float *) malloc(NPhotons*NScatRec*3*sizeof(float));
#endif
for (i = 0; i< NPhotons; i++)
{
XArr[i] = 0;
X0Arr[i] = 0;
InterArr[i] = -1;
NscatArr[i] = -1;
#ifdef GETPOSDIR
PosArr[3*i] = 0;
PosArr[3*i+1] = 0;
PosArr[3*i+2] = 0;
AngleArr[2*i] = 0;
AngleArr[2*i+1] = 0;
for (j = 0;j<NScatRec;j++)
{
PosArrLong[0+ 3*i + 3*NPhotons*j] = 0;
PosArrLong[1+ 3*i + 3*NPhotons*j] = 0;
PosArrLong[2+ 3*i + 3*NPhotons*j] = 0;
}
#endif
}
if (b == 0.)
{
a_par = 4.693e-4 * sqrt(1./CellArr[idc].T);
vth = 12.85 * sqrt(CellArr[idc].T);
}
else
{
a_par = 4.693e-4 * sqrt(1./CellArr[idc].T);
// a_par = 4.693e-4 * (12.85/b);
// a_par = 4.7e-4 * (12.85/b);
// vth = ;
vth = 12.85 * sqrt(CellArr[idc].T);
}
if (VarXCrit==1)
{
x_medium = xp0 - vmax/vth;
tau_ini = sx_const * ColDens * pow(CellArr[idc].T,-0.5) * voigt(HList,x_medium);
if (tau_ini < 1e4)
xcrit = 3;
if (tau_ini >1e4 && tau_ini < 1e6)
xcrit = 6;
if (tau_ini > 1e6)
xcrit = 10;
//printf("1 xcrit: %f \n",xcrit);
}
(void) time(&t0);
for (ip=0;ip < NPhotons;ip++)
{
nscat = 0;
if( ip > 999 & ip % 1000 == 0)
{
printf("Photon %ld\n",ip);
if( first_time==0 )
{
first_time=1;
printf("Estimated time to finish: %f [min] \n",1000*op_time * (NPhotons - ip) );
}
}
// Initialise photon's frequency, direction and position.
xi0 = gsl_rng_uniform (r);
xi1 = gsl_rng_uniform (r);
xi2 = gsl_rng_uniform (r);
xi3 = gsl_rng_uniform (r);
xi4 = gsl_rng_uniform (r);
xi5 = gsl_rng_uniform (r);
init_photon(P,ip, xi0, xi1, xi2);
dnd = (vth*nu0)/c;
flag_zero = 0;
(void) time(&t1);
i = 0;
xi1 = gsl_rng_uniform (r);
xi2 = gsl_rng_uniform (r);
xi3 = gsl_rng_uniform (r);
idc_old = 0;
while(idc != -1)
{
t_0 = - log(gsl_rng_uniform (r));
EscCond = 0;
P[ip].ni = sin(th0)*cos(ph0);
P[ip].nj = sin(th0)*sin(ph0);
P[ip].nk = cos(th0);
while(t_0 > 0.)
{
// Shortcut to compute crossing of empty cells, where no optical depth (t_0) is *used*.
empty_cells(P,ip);
H_x = voigt(HList, P[ip].xp);
if(isnan(H_x))
printf("H_x is nan\n");
// H_x = 0.; // H_x disables H scattering.
#ifdef TCONST
s_nH = TPar * H_x*CellArr[idc].nH;
#else
s_nH = sx_const * pow(CellArr[idc].T,-0.5)*H_x*CellArr[idc].nH;
#endif
#ifdef TAUGUIDERDONI
s_nd = Ext_Ratio * pow(CellArr[idc].z/zstar,spar) * CellArr[idc].nH/NHConst;
#else
s_nd = ext_zstar * CellArr[idc].z * CellArr[idc].nH;
#endif
s_sum = s_nH + s_nd;
s = t_0 / s_sum;
radius = sqrt( SQR(P[ip].x) + SQR(P[ip].y)+ SQR(P[ip].z));
// The position of the photon after consuming its optical depth is computed here:
s_ = crossing_cells(P,gtype,ip);
rx0 = P[ip].x;
ry0 = P[ip].y;
rz0 = P[ip].z;
ni = P[ip].ni;
nj = P[ip].nj;
nk = P[ip].nk;
}
if (EscCond == 1)
{
#ifndef TEST_RII
idc = -1;
#else
idc = 0;
#endif
if (idc == -1)
{
escape:
x = P[ip].xp + (P[ip].ni*vbulk_x + P[ip].nj*vbulk_y + P[ip].nk*vbulk_z)/vth;
// x = c*(g*nup - nu0)/(vth*nu0) - g*(nup/nu0)*(ni*vbulk_x + nj*vbulk_y + nk*vbulk_z)/vth;
// dprintd(x);
// printf("Photon has escaped in %ld scatterings\n",nscat);
// ................................
inter = 4;
(void) time(&t2);
op_time = (float) (t2-t1)/60.;
// printf("Total calculation took %f minutes.\n",op_time);
if (strcmp(OutMode,"Long")==0)
{
printf("\n");
record_data_long(nscat,ip,x,P[ip].x,P[ip].y,P[ip].z,r0,upar,uper1,uper2,H_x,P[ip].xp,inter);
}
else
{
// record_data_short(nscat,ip,x,rxf,ryf,rzf,radius,H_x,inter,op_time,flag_zero);
XArr[ip] = x;
X0Arr[ip]=xp0;
InterArr[ip] = inter;
NscatArr[ip] = nscat;
#ifdef GETPOSDIR
PosArr[3*ip] = P[ip].x;
PosArr[3*ip+1] = P[ip].y;
PosArr[3*ip+2] = P[ip].z;
AngleArr[2*ip] = P[ip].th;
AngleArr[2*ip+1]= P[ip].ph;
// record_data_pos(nscat,ip,x,ph0,th0,rxf,ryf,rzf,inter,op_time,flag_zero);
//#else
// record_data_short(nscat,ip,x,ph0,th0,radius,inter,op_time,flag_zero);
#endif
}
nout++;
goto end;
break;
}
}
else
{
rx0 = rxf;
ry0 = ryf;
rz0 = rzf;
}
P_H = s_nH / s_sum;
xi1 = gsl_rng_uniform (r);
if (strcmp(IncDust,"Yes")==0)
inter = (xi1 <= P_H)? 1 : 2 ;
else
inter = 1;
switch(inter) // inter = 1 means interacting with hydrogen, inter = 2 means dust.
{
case 1:
#ifdef USEREJECTION
upar = -999.0;
i = 0;
do
{
xi0 = gsl_rng_uniform (r);
xi1 = gsl_rng_uniform (r);
xi2 = gsl_rng_uniform (r);
upar = vp_rejection(xp,a_par,xi0,xi1,xi2);
i++;
} while(upar == -999.0);
// if (i > 100000)
// printf("VP_REJECTION TOOK %d tries to get upar = %f, x = %f, nscatter = %d\n" \
,i,upar,xp,nscat);
#endif
xi0 = gsl_rng_uniform (r);
xi1 = gsl_rng_uniform (r);
xi2 = gsl_rng_uniform (r);
xi3 = gsl_rng_uniform (r);
xi3 = (xi3 == 0.0) ? gsl_rng_uniform (r) : xi3;
xi4 = gsl_rng_uniform (r);
xi5 = gsl_rng_uniform (r);
xi6 = gsl_rng_uniform (r);
xi7 = gsl_rng_uniform (r);
scattering_hydrogen(P,ip);
break;
case 2:
xi1 = gsl_rng_uniform (r);
xi2 = gsl_rng_uniform (r);
xi3 = gsl_rng_uniform (r);
dust_interaction(P,ip);
if (end_syg ==1)
goto end;
break;
}
// dprinti(nscat);
/*
if (nscat == 1000000 || nscat == 10000000 )
{
printf("********************************************\n");
printf("Number of scatterings so far: %ld\n",nscat);
printf("Photon's location %f %f %f\n",rxf,ryf,rzf);
dprintf(x);
dprintf(xp);
dprintf(th0);
dprintf(ph0);
}
*/
#ifdef WRITEALL
if (ip < 1000)
{
x = P[ip].xp + (P[ip].ni*vbulk_x + P[ip].nj*vbulk_y + P[ip].nk*vbulk_z)/vth;
record_data_long(nscat,ip,x,P[ip].x,P[ip].y,P[ip].z,r0,upar,uper1,uper2,H_x,\
P[ip].xp,inter);
}
#endif
if (gtype ==1)
{
if (r0 < 0.99*R_inner)
{
printf("scatter %d of photon %d occurs within empty zone. Something is not ok\n",nscat,ip);
printf("rx/r_inner %f ry/r_inner %f rz/r_inner %f radius/r_inner %f\nidc %d\n",\
P[ip].x/R_inner,P[ip].y/R_inner,P[ip].z/R_inner,r0/R_inner,idc);
}
}
nscat++;
}
end:
// printf("done\n");
if (strcmp(Set_Tolerance,"yes") == 0)
{
// if ((ip >= np_min && nout >= nout_max) || \
// (ip >= np_max))
if ((ip >= np_min && nout >= nout_max) || \
(ip >= np_max) )
// (ip >= np_max && nout >= (int) nout_max/5) || \
{
printf("Max number of absorbed photons or limit on the number of photons reached, exiting...\n");
#ifdef GETPOSDIR
printf("Writing data\n");
record_data_pos(ip);
printf("File %s written\n",OutShort);
free(PosArr);
free(AngleArr);
#else
record_data_short();
#endif
free(HList);
free(DipList);
free(HGList);
free(CellArr);
exit(0);
}
}
#ifdef TIMELIMIT
(void) time(&t4);
t4 = (float) (t4-t0)/60.;
if (t4 > MAXTIME)
{
printf("MAXTIME reached, forcing output and exit\n");
#ifdef GETPOSDIR
record_data_pos(ip);
printf("File %s written\n",OutShort);
free(PosArr);
free(AngleArr);
#else
record_data_short();
#endif
exit(0);
}
#endif
//printf("%ld %f\n",ip,xp);
}
int main (int argc, char* argv[]) {
char filename1[200];
char filename2[200];
char pairs_file[200];
char fileout[200];
FILE* query_fp = 0;
FILE* reference_fp = 0;
FILE* fp_pairs = 0;
FILE* fpout = stdout;
int total_pairs = 0;
pair_struct* pairs = 0;
/* Set Default Parameter Values*/
length_5p_for_weighting = 8; /* The 5' sequence length to be weighed except for the last residue*/
scale = 4.0; /* The 5' miRNA scaling parameter*/
strict = 0; /* Strict seed model on/off*/
debug = 0; /* Debugging mode on/off*/
key_value_pairs = 0;
gap_open = -9.0; /* Gap-open Penalty*/
gap_extend = -4.0; /* Gap-extend Penalty*/
score_threshold = 140.0; /* SW Score Threshold for reporting hits*/
energy_threshold = 1.0; /* Energy Threshold (DG) for reporting hits*/
verbosity = 1; /* Verbose mode on/off*/
outfile = 0; /* Dump to file on/off*/
truncated = 0; /* Truncate sequences on/off*/
no_energy = 0; /* Turn off Vienna Energy Calcs - FASTER*/
restricted = 0; /* Perform restricted search space*/
parse_command_line(argc, argv, filename1, filename2, fileout, pairs_file);
if (gap_open > 0.0 || gap_extend > 0.0) {
fprintf(stderr, "Error: gap penalties may not be greater than 0\n");
return 1;
}
if (truncated < 0) {
fprintf(stderr, "Error: negative value give for UTR truncation\n");
return 1;
}
if ((query_fp = fopen(filename1, "r")) == NULL) {
fprintf(stderr, "Error: Cannot open file %s\n", filename1);
return 1;
}
if ((reference_fp = fopen(filename2, "r")) == NULL) {
fprintf(stderr, "Error: Cannot open file %s\n", filename2);
return 1;
}
fclose(reference_fp);
if ((outfile) && ((fpout = fopen(fileout, "w")) == NULL)) {
fprintf(stderr, "Error: Cannot create output file %s\n", fileout);
return 1;
}
if (restricted) {
if ((fp_pairs = fopen(pairs_file, "r")) == NULL) {
fprintf(stderr, "Error: Cannot open restrict pairs file %s\n", pairs_file);
return 1;
}
/* Initialize the pairs list for restriced searches*/
total_pairs = load_pairs(fp_pairs, &pairs);
fclose(fp_pairs);
}
initialize_globals();
print_parameters(filename1, filename2, fpout);
if (restricted && verbosity) {
printf("Performing Restricted Scan on:%d pairs\n", total_pairs);
}
find_targets(query_fp, fpout, pairs, total_pairs, filename2);
destroy_globals();
if (outfile) fclose(fpout);
fclose(query_fp);
return 0;
}
