void raw2() { typedef double Scalar; Experiment<Scalar> *x = new LorenzExperiment(); // RungeKutta4 *rk4 = dynamic_cast<RungeKutta4*>(x->integrator); // rk4->setRealParamValue("stepSize", .001); x->setIntegrator("rk4"); std::cout << x->integrator->getName() << std::endl; std::cout << "New Vector\n"; DTS::Vector<Scalar> v(4), v2(4); v[0] = 1; v[1] = 1; v[2] = 1; v[3] = 0; for (int i =0; i < 100000000; i++) { // for (int i =0; i < 10; i++) { x->integrator->step( v, v2 ); v2 += v; v = v2; } std::cout << v2 << std::endl; x->model->printRealParams(); delete x; }
void MainWindowImpl::openModel(QTreeWidgetItem *item) { Experiment *experiment = new Experiment("/home/ahlatimer/vset"); std::vector<Model> models = experiment->getModels(); std::string model_type = ""; std::string iteration = ""; std::string step = ""; if(item->text(0) == "Coverage") { model_type = "icov"; } else if(item->text(0) == "Time") { model_type = "time"; } else if(item->text(0) == "Vel Perturbation") { model_type = "dusum"; } else if(item->text(0) == "Smoother 1") { model_type = "velaa"; } else if(item->text(9) == "Smoother 2") { model_type = "dvaa"; } for(int i = 0; i < models.size(); i++) { iteration = intToString(models[i].getIteration()); step = intToString(models[i].getStep()); if(models[i].getName() == model_type && item->text(1) == QString::fromStdString(iteration) && item->text(2) == QString::fromStdString(step)) { models[i].render(); return; } } }
// function that reads in data from file into data maps static bool readFromFile(DataManager<T>& data, const std::string& dataPath) { // declare vector for saving file names std::vector<std::string> fileList; try { // get file list getFileList(fileList, dataPath); // count number of files size_t noOfFiles{fileList.size()}; // loop through all files for (size_t i{}; i < noOfFiles; ++i) { // declare experiment object Experiment<T> userExperiment; // pass file name to experiment read from file function userExperiment.readFromFile(fileList[i]); // insert data into maps data.insertExperiment(userExperiment); } } catch (const std::invalid_argument& e) { ErrorMsg::print(e.what()); return false; } return true; }
// function that reads in data from screen into data maps static bool readFromScreen(DataManager<T>& data) { bool finished{false}; while (!finished) { // declare experiment object Experiment<T> experiment; try { // call read from screen function experiment.readFromScreen(); } catch (const std::invalid_argument& e) { ErrorMsg::print(e.what()); return false; } // insert data into maps data.insertExperiment(experiment); ScreenMsg::print("Type <y> to add another experiment "); ScreenMsg::print("or any other letter to finish >> "); std::string reply{getInput<std::string>()}; // convert to uppercase letters in case user used upper case std::transform(reply.begin(), reply.end(), reply.begin(), ::toupper); // check reply if (reply == "Y") { continue; } else { finished = true; break; } } return true; }
//SELECTION void Viewer::postSelection(const QPoint& point){ int experimentState=0; // Compute orig and dir, used to draw a representation of the intersecting line //camera()->convertClickToLine(point, orig, dir); //Click and returns the state of the experiment: //- 0: The Experiment doesn't have started //- 1: The Experiment has started, shows the current block //- 2: Finished Experiment, doesn't show anything experimentState=exper.click(point); if(experimentState==2){ thanks(); } addMessage("click x: ",point.x(),2); addMessage("click y: ",point.y(),3); clicks++; addMessage("Clicks: ",clicks,4); addMessage("Experiment state: ",experimentState,5); addMessage("Block: ",exper.getCurrentBlock(),6); addMessage("Trial: ",exper.getCurrentTrial(),7); }
double run_experiment(const Experiment & experiment, Generator gen, int n) { generic_counter<std::vector<int> > v(experiment.classes()); experiment.run(gen, v, n); return chi_square_value(v.begin(), v.end(), std::bind1st(std::mem_fun_ref(&Experiment::probability), experiment)); }
int main(int argc, char *argv[]){ if(argc!=2){ cerr<<"Argument 1 required"<<endl; return -1; } if(SRAND_ON){ srand(time(NULL)); } vector<string> server_list = SERVER_LIST; //{"10.129.26.246:8091", "10.129.28.141:8091", "10.129.26.81:8091"}; vector<string> key = DataSetGenerator::getRandomStrings(DATASET_SIZE,KEY_SIZE); vector<string> value = DataSetGenerator::getRandomStrings(DATASET_SIZE,VALUE_SIZE); int thread_count = THREAD_COUNT; int run_time = RUN_TIME; vector<string> conn = CONN; Experiment e = Experiment(key, value, conn, thread_count, run_time,DIST==ZIPF); //vector<string> &k, vector<string> &v, string con, int tc, int rt, int dist string sep="/"; string DATE=currentDateTime("%Y-%m-%d"); string iter_num = string(argv[1]); string folder=string(DS)+sep+DATE+sep+"TC"+to_string(thread_count)+sep+iter_num+sep; cout<<folder<<endl; system((string("mkdir -p ")+folder).c_str()); SystemMonitor sm(server_list,folder); // e.setReadProb(0.5); // e.runExperiment(folder + "RP_"+to_string(e.getReadProb())); // // e.setReadProb(1); // e.runExperiment(folder + "RP_"+to_string(e.getReadProb())); sm.startMonitoring(); e.setReadProb(READPROB); e.runExperiment(folder + "RP_"+to_string(e.getReadProb())); sm.stopMonitoring(); // sm.startMonitoring(); // e.setReadProb(0.95); // e.runExperiment(folder + "RP_"+to_string(e.getReadProb())); // sm.stopMonitoring(); // long num_cpus = std::thread::hardware_concurrency(); // string detailes = "CPU count, CPU util, NW rx(KBps), NW tx(KBps), NW util, Mem Size, Mem util, Disk util, Page Faults"; return 0; }
int main() { printf("Running EagleTree\n"); set_small_SSD_config(); string name = "/demo_output/"; Experiment::create_base_folder(name.c_str()); Experiment* e = new Experiment(); Workload_Definition* workload = new Example_Workload(); e->set_workload(workload); e->set_io_limit(1000000); e->run("test"); e->draw_graphs(); delete workload; return 0; }
void ExperimentController::calculateEstimatedDuration() { Experiment experiment = this->experiment(); double duration = (boost::posix_time::microsec_clock::local_time() - experiment.startedAt()).total_milliseconds() - (experiment.pausedDuration() * 1000); double previousTargetTemp = HeatBlockInstance::getInstance()->temperature(); do { Stage *stage = experiment.protocol()->currentStage(); std::time_t holdTime = stage->currentStep()->holdTime(); double temperature = stage->currentStep()->temperature(); if (stage->autoDelta() && stage->currentCycle() > stage->autoDeltaStartCycle()) { holdTime += stage->currentStep()->deltaDuration() * (stage->currentCycle() - stage->autoDeltaStartCycle()); if (holdTime < 0) holdTime = 0; temperature += stage->currentStep()->deltaTemperature() * (stage->currentCycle() - stage->autoDeltaStartCycle()); if (temperature < HeatBlockInstance::getInstance()->minTargetTemperature()) temperature = HeatBlockInstance::getInstance()->minTargetTemperature(); else if (temperature > HeatBlockInstance::getInstance()->maxTargetTemperature()) temperature = HeatBlockInstance::getInstance()->maxTargetTemperature(); } double rate = stage->currentRamp()->rate(); rate = rate > 0 && rate <= kDurationCalcHeatBlockRampSpeed ? rate : kDurationCalcHeatBlockRampSpeed; if (previousTargetTemp < temperature) duration += (((temperature - previousTargetTemp) / rate) + holdTime) * 1000; else duration += (((previousTargetTemp - temperature) / rate) + holdTime) * 1000; previousTargetTemp = temperature; } while (experiment.protocol()->advanceNextStep()); { Poco::RWLock::ScopedWriteLock lock(*_machineMutex); _experiment.setEstimatedDuration(std::round(duration / 1000)); } }
bool ExperimentModel::insertRow(int row, Experiment& e, const QModelIndex & parent) { beginInsertRows(parent, row, row); if(row > qExpMap.size() || row < 0) return false; qExpMap[e.getName()] = &e; endInsertRows(); return true; }
void ScenarioConverter::PrintNthExperiment( int n ) { char old_start, old_goal; int start_x, start_y, goal_x, goal_y; Experiment exp = this->scen->GetNthExperiment( n ); start_x = exp.GetStartX(); start_y = exp.GetStartY(); goal_x = exp.GetGoalX(); goal_y = exp.GetGoalY(); old_start = this->map[start_y][start_x]; old_goal = this->map[goal_y][goal_x]; this->map[start_y][start_x] = '@'; this->map[goal_y][goal_x] = '*'; this->PrintMap(); this->map[start_y][start_x] = old_start; this->map[goal_y][goal_x] = old_goal; }
/// @brief Evaluation of the metric in CPU cycles template<typename Experiment> inline double operator() ( Experiment const& e , std::string const& name , details::times_set const& , details::cycles_set const& c ) const { double m = Stat::evaluate(c) / e.size(); details::measures_map[details::identify_result(name,e,*this)] = m; return m; }
ScenarioConverter::ScenarioConverter( ScenarioLoader *scen ) { this->scen = scen; ifstream in; char scrap[256], type[256]; int rows, columns, i, j; Experiment exp = scen->GetNthExperiment( 0 ); /*cout << "map " << exp.GetMapName() << "\n";*/ in.open( exp.GetMapName(), ifstream::in ); in >> scrap; in >> type; in >> scrap; in >> rows; in >> scrap; in >> columns; in >> scrap; /*cout << "type " << type << "\n"; cout << "rows " << rows << "\n"; cout << "columns " << columns << "\n";*/ this->rows = rows; this->columns = columns; this->map = (char**)malloc( sizeof(char*) * rows ); for( i = 0; i < rows; i++ ) this->map[i] = (char*)malloc( sizeof(char) * columns ); in.get(); /*newline*/ for( i = 0; i < rows; i++ ) { for( j = 0; j < columns; j++ ) this->map[i][j] = in.get(); in.get(); /*newline*/ } }
int main() { printf("Running EagleTree\n"); set_small_SSD_config(); // set_big_SSD_config(); //gogo greedy // GARBAGE_COLLECTION_POLICY = 0; // string name = "/greedy_demo_output/"; // gogo LRU GARBAGE_COLLECTION_POLICY = 1; string name = "/lru_demo_output/"; //gogo dj // GARBAGE_COLLECTION_POLICY = 2; // string name = "/demo_output_500/"; FTL_DESIGN = 1; // using DFTL SCHEDULING_SCHEME = 7; PRINT_LEVEL = 0; MAX_SSD_QUEUE_SIZE = 16; ftl_cache::CACHED_ENTRIES_THRESHOLD = pow(2,15); // SRAM fitting 256 kb, or 2^25 entries, DFTL::ENTRIES_PER_TRANSLATION_PAGE = 128; Experiment::create_base_folder(name.c_str()); Experiment* e = new Experiment(); Workload_Definition* workload = new Example_Workload(); e->set_workload(workload); printf("NUMBER_OF_ADDRESSABLE_PAGES: %d %d\n", NUMBER_OF_ADDRESSABLE_PAGES(), (int)(NUMBER_OF_ADDRESSABLE_PAGES() * OVER_PROVISIONING_FACTOR)); e->set_io_limit(3000000); // e->set_io_limit(30000000); // e->set_io_limit(pow(2,0)); e->run("test"); e->draw_graphs(); delete workload; return 0; }
void MainFrame::analyzeIndividual( wxCommandEvent& event ) { int generation = generationSpinner->GetValue(); int individual = individualSpinner->GetValue(); string title; title += populationFileName + string("_") + string("Generation: ") + toString(generation) + string(" Individual: ") + toString(individual); mutex *populationMutex = experimentRun.getPopulationMutex(); { mutex::scoped_lock scoped_lock(*populationMutex); Experiment *experiment = experimentRun.getExperiment()->clone(); shared_ptr<NEAT::GeneticIndividual> indiv( new NEAT::GeneticIndividual( *(experimentRun.getIndividual(generation-1,individual-1).get()) ) ); experiment->processIndividualPostHoc(indiv); if (indiv->getUserData().length()) { cout_ << "PRINTING USER DATA RESULTS:\n"; cout_ << indiv->getUserData() << endl; } delete experiment; } }
void Viewer::draw(){ startScreenCoordinatesSystem(); exper.paint(width(),height()); stopScreenCoordinatesSystem(); cursor=falcon.getPos(); if(falcon.getClick(0)||falcon.getClick(1)||falcon.getClick(2)||falcon.getClick(3)){ const QPoint point((int)cursor.getX(),(int)cursor.getY()); postSelection(point); } drawCursor(); addMessage("Width: ",width(),0); addMessage("Height: ",height(),1); displayMessages(); }
int main() { cout << "Computational Exercise 4.2a)\n\nDouble Slit\n" << endl; DoubleSlit *slit = new DoubleSlit(62,272); cout << "Slit has width = " << slit->Width() << " nm and Distance = " << slit->Distance() << " nm" << endl; Electron *elec = new Electron(300); cout << "The Electron has a lambda of " << elec->Lambda() << endl; // Idee: Electron erzeugen // Winkel zuordnen nach Wahrscheinlichkeitsverteilung // Seeding srand(time(NULL)); Experiment *expe = new Experiment(*elec,*slit); cout << "\nDie Minima der Intensität liegen bei: " << expe->Minima() << endl; expe->printEx(10000); cout << "\n *** Starte Experiment mit normalverteilter Spannung ***" << endl; // SecondExperiment(DoubleSlit slit, unsigned int numberOfElec,unsigned int numberOfBins, double U,double deltaU, SecondExperiment *expe2 = new SecondExperiment(*slit,10000,200,300.,10.); expe2->printExp(); expe2->printNormv(); cout << "\n +++ Finished! +++" << endl; delete expe; delete elec; delete slit; return 0; }
// experiments with 0, 10, ..., 100 differential heuristics void RunExperiments1(ScenarioLoader *sl) { std::vector<graphState> aPath; Map *m = new Map(sl->GetNthExperiment(0).GetMapName()); m->Scale(sl->GetNthExperiment(0).GetXScale(), sl->GetNthExperiment(0).GetYScale()); Graph *g = GraphSearchConstants::GetGraph(m); GraphDistanceHeuristic diffHeuristic(g); diffHeuristic.SetPlacement(kAvoidPlacement); GraphEnvironment gEnv(g, &diffHeuristic); gEnv.SetDirected(true); TemplateAStar<graphState, graphMove, GraphEnvironment> taNew; for (int z = 0; z <= 10; z++) { for (int x = 0; x < sl->GetNumExperiments(); x++) { Experiment e = sl->GetNthExperiment(x); graphState start, goal; start = m->GetNodeNum(e.GetStartX(), e.GetStartY()); goal = m->GetNodeNum(e.GetGoalX(), e.GetGoalY()); Timer t; t.StartTimer(); taNew.GetPath(&gEnv, start, goal, aPath); t.EndTimer(); printf("%d\t%d\t%lld\t%f\n", e.GetBucket(), diffHeuristic.GetNumHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime()); } for (int x = 0; x < 10; x++) diffHeuristic.AddHeuristic(); } exit(0); }
int main() { printf("Running EagleTree\n"); set_small_SSD_config(); string name = "/demo_output/"; Experiment::create_base_folder(name.c_str()); Workload_Definition* init = new Init_Workload(); string calibration_file = "calib.txt"; SCHEDULING_SCHEME = 1; // use the noop IO scheduler during calibration because it's fastest in terms of real execution time Experiment::calibrate_and_save(init, calibration_file); delete init; Experiment* e = new Experiment(); e->set_calibration_file(calibration_file); Workload_Definition* workload = new Asynch_Random_Workload(); e->set_workload(workload); e->set_io_limit(1000000); SCHEDULING_SCHEME = 0; // use a fifo IO scheduler during the actual experiment e->run("test"); e->draw_graphs(); delete workload; return 0; }
ExperimentController::StartingResult ExperimentController::start(int experimentId) { if (OpticsInstance::getInstance()->lidOpen()) return LidIsOpen; Experiment experiment = _dbControl->getExperiment(experimentId); if (experiment.empty() || !experiment.protocol()) return ExperimentNotFound; else if (experiment.startedAt() != boost::posix_time::not_a_date_time) return ExperimentUsed; experiment.setStartedAt(boost::posix_time::microsec_clock::local_time()); if (machineState() != IdleMachineState) return MachineRunning; stopLogging(); { Poco::RWLock::ScopedWriteLock lock(*_machineMutex); _settings.temperatureLogsState = false; _settings.debugTemperatureLogsState = false; LidInstance::getInstance()->setTargetTemperature(experiment.protocol()->lidTemperature()); _dbControl->startExperiment(experiment); _machineState = LidHeatingMachineState; _experiment = std::move(experiment); LidInstance::getInstance()->setEnableMode(true); } startLogging(); return Started; }
int main(int argc, char* argv[]) { printf("Running sequential!!\n"); char* results_file = ""; if (argc == 1) { printf("Setting big SSD config\n"); set_big_SSD(); } else if (argc == 3) { char* config_file_name = argv[1]; printf("Setting config from file: %s\n", config_file_name); results_file = argv[2]; printf("results_file: %s\n", results_file); load_config(config_file_name); } string name = "/exp_sequential/"; string exp_folder = get_current_dir_name() + name; Experiment::create_base_folder(exp_folder.c_str()); //set_big_SSD(); //OVER_PROVISIONING_FACTOR = 0.70; Workload_Definition* workload = new File_System_With_Noise(); OS_SCHEDULER = 1; vector<vector<Experiment_Result> > exps; Experiment* e = new Experiment(); e->set_io_limit(200000); //e->set_generate_trace_file(true); if (argc == 1) { BLOCK_MANAGER_ID = 0; string no_locality_calibration_file = "no_locality_calibration_file.txt"; Experiment::calibrate_and_save(workload, no_locality_calibration_file, 4 * NUMBER_OF_ADDRESSABLE_PAGES()); e->set_calibration_file(no_locality_calibration_file); e->run("no_locality"); BLOCK_MANAGER_ID = 2; ENABLE_TAGGING = true; string locality_calibration_file = "locality_calibration_file.txt"; Experiment::calibrate_and_save(workload, locality_calibration_file); e->set_calibration_file(locality_calibration_file); e->run("locality"); } else if (argc == 3 && BLOCK_MANAGER_ID == 0) { printf("running no locality\n"); string no_locality_calibration_file = "no_locality_calibration_file.txt"; e->set_calibration_file(no_locality_calibration_file); e->set_alternate_location_for_results_file(results_file); e->run("no_locality"); } else if (argc == 3 && BLOCK_MANAGER_ID == 2) { printf("running locality\n"); string locality_calibration_file = "locality_calibration_file.txt"; e->set_calibration_file(locality_calibration_file); e->set_alternate_location_for_results_file(results_file); e->run("locality"); } e->draw_graphs(); delete workload; delete e; //BLOCK_MANAGER_ID = 3; //ENABLE_TAGGING = true; //Experiment_Runner::calibrate_and_save(workload, true); //vector<Experiment_Result> er = Experiment::simple_experiment(workload, "sequential", IO_limit, OVER_PROVISIONING_FACTOR, space_min, space_max, space_inc); //exps.push_back(er); //exp.push_back( Experiment_Runner::overprovisioning_experiment(detection_LUN, space_min, space_max, space_inc, exp_folder + "seq_detect_lun/", "Seq Detect: LUN", IO_limit) ); //exp.push_back( Experiment_Runner::simple_experiment(experiment, Init_Workload, space_min, space_max, space_inc, exp_folder + "oracle/", "Oracle", IO_limit) ); //exp.push_back( Experiment_Runner::overprovisioning_experiment(shortest_queues, space_min, space_max, space_inc, exp_folder + "shortest_queues/", "Shortest Queues", IO_limit) ); /*Experiment_Runner::draw_graphs(exps, exp_folder); vector<int> num_write_thread_values_to_show; for (double i = space_min; i <= space_max; i += space_inc) num_write_thread_values_to_show.push_back(i); // Show all used spaces values in multi-graphs Experiment_Runner::draw_experiment_spesific_graphs(exps, exp_folder, num_write_thread_values_to_show); chdir(".."); // Leaving*/ return 0; }
// Compare: // * 1 random lookup of 10 with BPMX // * 1 random lookup of 10 without BPMX // * octile // * max of 10 heuristics // * 1 lookup in compressed heuristic void RunExperiments4(ScenarioLoader *sl) { std::vector<graphState> aPath; Map *m = new Map(sl->GetNthExperiment(0).GetMapName()); m->Scale(sl->GetNthExperiment(0).GetXScale(), sl->GetNthExperiment(0).GetYScale()); Graph *g = GraphSearchConstants::GetGraph(m); GraphMapInconsistentHeuristic diffHeuristic(m, g); diffHeuristic.SetPlacement(kAvoidPlacement); diffHeuristic.SetMode(kRandom); GraphEnvironment gEnv(g, &diffHeuristic); gEnv.SetDirected(true); TemplateAStar<graphState, graphMove, GraphEnvironment> taNew; Timer t; for (int x = 0; x < 10; x++) diffHeuristic.AddHeuristic(); //diffHeuristic.SetNumUsedHeuristics(diffHeuristic.GetNumHeuristics()/10); for (int x = 0; x < sl->GetNumExperiments(); x++) { Experiment e = sl->GetNthExperiment(x); graphState start, goal; start = m->GetNodeNum(e.GetStartX(), e.GetStartY()); goal = m->GetNodeNum(e.GetGoalX(), e.GetGoalY()); printf("%d\t", e.GetBucket()); // N memory -- 1 heuristic diffHeuristic.SetNumUsedHeuristics(1); diffHeuristic.SetMode(kMax); taNew.SetUseBPMX(0); t.StartTimer(); taNew.GetPath(&gEnv, start, goal, aPath); t.EndTimer(); printf("%df\t%lld\t%f\t%f\t", diffHeuristic.GetNumHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime(), gEnv.GetPathLength(aPath)); // N memory -- 10 compressed heuristics no BPMX diffHeuristic.SetNumUsedHeuristics(10); diffHeuristic.SetMode(kCompressed); taNew.SetUseBPMX(0); t.StartTimer(); taNew.GetPath(&gEnv, start, goal, aPath); t.EndTimer(); printf("%dc\t%lld\t%f\t%f\t", diffHeuristic.GetNumHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime(), gEnv.GetPathLength(aPath)); // N memory -- 10 compressed heuristics BPMX 1 diffHeuristic.SetNumUsedHeuristics(10); diffHeuristic.SetMode(kCompressed); taNew.SetUseBPMX(1); t.StartTimer(); taNew.GetPath(&gEnv, start, goal, aPath); t.EndTimer(); printf("%dcb1\t%lld\t%f\t%f\t", diffHeuristic.GetNumHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime(), gEnv.GetPathLength(aPath)); // N memory -- 10 compressed heuristics BPMX(°) diffHeuristic.SetNumUsedHeuristics(10); diffHeuristic.SetMode(kCompressed); taNew.SetUseBPMX(1000); t.StartTimer(); taNew.GetPath(&gEnv, start, goal, aPath); t.EndTimer(); printf("%dcbi\t%lld\t%f\t%f\n", diffHeuristic.GetNumHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime(), gEnv.GetPathLength(aPath)); } exit(0); }
int main(int argc, char* argv[]) { if (argc < 2) { std::cout << "Insufficient arguments" << std::endl; std::cout << "Usage : simulate <params file>" << std::endl; exit(1); } // arguments std::string paramfile = std::string(argv[1]); Experiment* e; // read parameters from file and create experiment object e = new Experiment(paramfile); std::cout << "Simulation parameters" << std::endl; std::cout << "From file : " << paramfile << std::endl; std::cout << *e << std::endl; // setup tree to write out TFile f("outfile.root", "RECREATE"); TTree *tree = new TTree("T", "Experiments from the Stopped Particle MC"); tree->Branch("Experiment", "Experiment", &e); // fills file std::ofstream fillsfile; fillsfile.open("fills.txt"); // setup simulation Simulator sim; // set parameters sim.setParameters(e); // set observed events sim.setupObservedEvents(); // set up luminosity data sim.setupLumi(false, true, true, e->lumiFile); // set up lifetime mask sim.setupLifetimeMask(); // sim.getLhcFills().print(std::cout); // simulate everything at once unsigned firstFill = e->fills.at(0); unsigned lastFill = e->fills.at(e->fills.size()-1); // expected background sim.calculateExpectedBG(firstFill, lastFill); // get observed events sim.calculateObservedEvents(firstFill, lastFill); // run MC sim.simulateSignal(firstFill, lastFill); // calculate limit sim.calculateLimit(); std::cout << std::endl; // write results summary std::ofstream summaryfile; summaryfile.open("summary.txt", std::ios::app); e->summary(summaryfile); summaryfile.close(); std::cout << *e << std::endl; tree->Fill(); f.cd(); tree->Write(); fillsfile.close(); return 0; }
int main(int argc, char** argv){ //flags set by command line options int verbose_flag = 0; int graphviz_flag = 0; int gnuplot_flag = 0; int outputall_flag = 0; int csvCell_flag = 0; int csvData_flag = 0; int usage_flag = 0; int gillespie_flag = 0; int rungeKutta_flag = 0; // used by command line parser int c; //trace related trace messages t.addTraceType("trce",0); //program arguments t.addTraceType("args",0); //error messages t.addTraceType("error",1); //object creation / construction t.addTraceType("init",1); //memory location of created objects t.addTraceType("mloc",1); //object deletion / destruction t.addTraceType("free",1); //calculated effect of interactions t.addTraceType("efct",0); //generational messages t.addTraceType("gens",0); // runge kutta (data / general messages) t.addTraceType("rk-4",0); // runge kutta (rk vals) t.addTraceType("rk-val",0); // runge kutta (calculation of next points) t.addTraceType("rk-new",0); // hill / goodwin term calculation (transcription::getEffect) t.addTraceType("hill",0); // molecule scoring t.addTraceType("score",0); // mutation t.addTraceType("mutate",1); // polymorphic comparisons (not used?) t.addTraceType("typeid",0); t.addTraceType("stoch",1); int numCells = 2; int numGenerations = 10; int scoringInterval = 1; int maxBasic = 1; int maxPTM = 1; int maxComp = 1; int maxPromoter = 1; float minKineticRate = 0; float maxKineticRate = 1; float initialConcentration = 0; float rkTimeLimit = 20; float rkTimeStep = .05; // this loop parses the command line options. it was mostly adapted from online examples while(1){ //define the command line options and their usage static struct option long_options[] = { {"help", no_argument, &usage_flag, 1}, {"usage", no_argument, &usage_flag, 1}, {"graphviz", no_argument, &graphviz_flag, 1}, {"gnuplot", no_argument, &gnuplot_flag, 1}, {"outputall", no_argument, &outputall_flag, 1}, {"csvCell", no_argument, &csvCell_flag, 1}, {"csvData", no_argument, &csvData_flag, 1}, {"deterministic", no_argument, &rungeKutta_flag, 1}, {"stochastic", no_argument, &gillespie_flag, 1}, {"cells", required_argument, 0, 'c'}, {"gens", required_argument, 0, 'g'}, {"minrate", required_argument, 0, 'a'}, {"maxrate", required_argument, 0, 'b'}, {"maxbasic", required_argument, 0, 'd'}, {"maxptm", required_argument, 0, 'e'}, {"maxcomp", required_argument, 0, 'f'}, {"maxprom", required_argument, 0, 'h'}, {"initconc", required_argument, 0, 'i'}, {"rklim", required_argument, 0, 'j'}, {"rkstep", required_argument, 0, 'k'}, {"interval", required_argument, 0, 'l'}, {"hill", required_argument, 0, 'm'}, {0,0,0,0} }; int option_index = 0; // which argument is currently seen? c = getopt_long (argc, argv, "a:b:c:d:e:f:g:h:i:j:k:l:", long_options, &option_index); if (c == -1) break; // what effect does that argument have switch(c) { case 0: if(long_options[option_index].flag != 0) break; printf("option %s", long_options[option_index].name); if (optarg) printf(" with arg %s", optarg); printf("\n"); break; case 'a': minKineticRate = atof(optarg); break; case 'b': maxKineticRate = atof(optarg); break; case 'c': numCells = atoi(optarg); break; case 'd': maxBasic = atoi(optarg); break; case 'e': maxPTM = atoi(optarg); break; case 'f': maxComp = atoi(optarg); break; case 'g': numGenerations = atoi(optarg); break; case 'h': maxPromoter = atoi(optarg); break; case 'i': initialConcentration = atof(optarg); break; case 'j': rkTimeLimit = atof(optarg); break; case 'k': rkTimeStep = atof(optarg); break; case 'l': scoringInterval = atoi(optarg); break; case 'm': hillParam = atoi(optarg); break; case '?': break; default: abort(); } } if (usage_flag){ printf("EvoDevo Help\n"); printf("---------------------------\n"); printf("Flags:\n"); printf(" --help This help message\n"); printf(" --usage This help message\n"); printf(" --graphviz Output graphviz png files displaying the cell configuration\n"); printf(" --gnuplot Output gnuplot png files displaying molecule concentrations over time\n"); printf(" --outputall Output data about each cell every generation\n"); printf(" --csvCell Output csv data containing cell configuration\n"); printf(" --csvData Output csv data containing molecule concentrations\n"); printf(" --deterministic Use deterministic Runge-Kutta solver for solving curves\n"); printf(" --stochastic Use stochastic gillespie algorithm for solving curves\n"); printf("\n"); printf("Parameters:\n"); printf(" --cells <int> Number of Cells to simulate\n"); printf(" --gens <int> Number of Generations to run for\n"); printf(" --minrate <float> Minimum value for random kinetic rates\n"); printf(" --maxrate <float> Maximum value for random kinetic rates\n"); printf(" --maxbasic <int> Maximum number of Basic Proteins\n"); printf(" --maxptm <int> Maximum number of Post Translationally Modified proteins\n"); printf(" --maxcomp <int> Maximum number of Protein-Protein Complexes\n"); printf(" --maxprom <int> Maximum number of Protein-Promoter Interactions\n"); printf(" --initconc <float> Initial concentration of molecules\n"); printf(" --rklim <float> Upper limit on time (x-axis) for differential equation solving\n"); printf(" --rkstep <float> Step size between points for differential equation solving\n"); printf(" --interval <int> Number of generations between equation solving and scoring\n"); printf(" --hill <int> Value of Hill Coefficient for DNA Transcription\n"); return 0; } // create our experiment with the options from the command line Experiment e = Experiment(numCells, numGenerations, maxBasic, maxPTM, maxComp, maxPromoter, minKineticRate, maxKineticRate, rkTimeLimit, rkTimeStep, initialConcentration, rungeKutta_flag, gillespie_flag); //set options related to output e.setOutputOptions(graphviz_flag, gnuplot_flag, outputall_flag, csvCell_flag, csvData_flag, scoringInterval); //start the experiment e.start(); return 0; }
/*! \todo Clarify that spatio_temporal_average specifies milliseconds from simulation start, not from simulation time window that is reported in the file. also produce an error message if interval not in file. Should actually probably go in the Stream_Playback_Control then. */ void spatiotemporal_average (URI blue_config_filename, Filename volume_compartment_mapping_filename, Filename output_filename_prefix, Millisecond begin_time, Millisecond end_time, Millisecond average_time_window, bool portable = false) { Count frames_per_second(10); // experiment Experiment experiment; experiment.open(blue_config_filename); Cell_Target circuit_target = experiment.cell_target("Column"); std::cout << "Microcircuit: loading target Column" << std::endl; Count j = 0; for (Cell_Target::const_iterator i = circuit_target.begin(); i != circuit_target.end(); ++i) { Neuron_Ptr new_neuron(new Neuron(experiment.microcircuit(), *i , j)); experiment.microcircuit().neurons().insert(new_neuron); ++j; } Volume_Temporal_Average<Millivolt, Micron, Millisecond> temporal_average(Count (average_time_window * frames_per_second)); Filter_Data<Microcircuit> microcircuit(experiment.microcircuit_ptr()); // pipeline setup Pipeline pipeline; std::cout << "Loading compartment report..." << std::endl; Reports_Specification::const_iterator result = experiment.reports().find("allCompartments"); if (result == experiment.reports().end()) { std::cerr << "No \"allCompartments\" report found" << std::endl; exit(1); } Compartment_Report_Stream_Reader<Millivolt> binary_report_reader(* result, 2); binary_report_reader.cell_target(circuit_target); Compartment_Report_Printer<Millivolt> printer; Compartment_Voltages_to_Microcircuit report_link; Compartment_Voltage_Voxel_Average voltage_volume_average(volume_compartment_mapping_filename, false); Volume_Voltage_to_Byte voltage_to_byte; binary_report_reader.time_window(begin_time, end_time); binary_report_reader.speed(1.0); voltage_to_byte.dynamic_range(-65.0, -20.0); std::cout << "Pipeline 1: Setup spatio-temporal average." << std::endl; pipeline = binary_report_reader + printer + report_link + microcircuit + voltage_volume_average + temporal_average; std::cout << "Pipeline 1: Started processing spatio-temporal average." << std::endl; pipeline.start(); pipeline.wait_until_finished(); pipeline.stop(); std::cout << "Pipeline 1: Temporal average finished." << std::endl; std::cout << "Pipeline 2: Setup NRRD volume file writer." << std::endl; Pipeline pipeline2; Filter_Reader<Volume<Millivolt, Micron, Millisecond> > volume_buffer_reader; volume_buffer_reader.input_ptr(temporal_average.output_ptr()); Volume_NRRD_File_Stream_Writer nrrd_file_writer(output_filename_prefix); pipeline2 = volume_buffer_reader + voltage_to_byte + nrrd_file_writer; std::cout << "Pipeline 2: Started writing volumes to disk." << std::endl; pipeline2.start(); pipeline2.wait_until_finished(); std::cout << "Pipeline 2: Written volumes to disk." << std::endl; }
int main(int argc, const char* argv[]) { /* * Build 48 Index with Links */ // Load Circuit Experiment experiment; experiment.open(blue_config_filename); Microcircuit & microcircuit = experiment.microcircuit(); const Targets & targets = experiment.targets(); const Cell_Target target = targets.cell_target("Column"); microcircuit.load(target, NEURONS | MORPHOLOGIES); //Make Neuron Rtrees ISpatialIndex *neuronTrees[MORPHOLOGIES_COUNT]; string *morphologyLabels[MORPHOLOGIES_COUNT]; int cm=0; Morphologies & myMorphologies = microcircuit.morphologies(); Morphologies::iterator myMorphologiesEnd = myMorphologies.end(); for (Morphologies::iterator i = myMorphologies.begin(); i != myMorphologiesEnd; ++i) { morphologyLabels[cm] = i->label(); neuronTrees[cm] = RTree::createNewRTree (createNewMemoryStorageManager(), 0.7, 127, 127, 3,RTree::RV_RSTAR,indexIdentifier); cm++; } Neurons & myNeurons = microcircuit.neurons(); Neurons::iterator myNeuronsEnd = myNeurons.end(); for (Neurons::iterator i = myNeurons.begin(); i != myNeuronsEnd; ++i) { cm=0; for (cm=0;cm<MORPHOLOGIES_COUNT;cm++) if (strcmp(i->morphology().label(),morphologyLabels[cm])==0) break; Transform_3D<Micron> trafo = i->global_transform(); Sections mySections = i->morphology().all_sections(); Sections::iterator mySectionsEnd = mySections.end(); for (Sections::iterator s = mySections.begin(); s != mySectionsEnd; ++s) { Segments segments = s->segments(); Segments::const_iterator segments_end = segments.end(); for (Segments::const_iterator j = segments.begin(); j != segments_end ; ++j) { vect plow, phigh; get_segment_mbr (*j, trafo, &plow, &phigh); SpatialIndex::Region mbr = SpatialIndex::Region(plow.data(),phigh.data(),3); std::stringstream strStream; strStream << i->gid() <<"-"<< s->id()<< "-" << j->id(); neuronTrees[cm]->insertData (strStream.str().length(), (byte*)(strStream.str().c_str()), mbr, segmentid); } } } // Make Morphology Rtrees Morphologies & myMorphologies = microcircuit.morphologies(); Morphologies::iterator myMorphologiesEnd = myMorphologies.end(); for (Morphologies::iterator i = myMorphologies.begin(); i != myMorphologiesEnd; ++i) { cout << "Indexing Morphology: " << i->label(); string baseName = i->label(); IStorageManager* diskfile = StorageManager::createNewDiskStorageManager(baseName, 4096); ISpatialIndex *tree = RTree::createNewRTree (*diskfile, 0.7, 127, 127, 3,RTree::RV_RSTAR,indexIdentifier); indexIdentifier++; segmentid=0; Sections mySections = i->all_sections(); Sections::iterator mySectionsEnd = mySections.end(); for (Sections::iterator s = mySections.begin(); s != mySectionsEnd; ++s) { Segments segments = s->segments(); Segments::const_iterator segments_end = segments.end(); for (Segments::const_iterator j = segments.begin(); j != segments_end ; ++j) { Box<bbp::Micron> Mbr = AABBCylinder::calculateAABBForCylinder(j->begin().center(), j->begin().radius(),j->end().center(),j->begin().radius()); vect plow, phigh; plow[0] = Mbr.center().x() - Mbr.dimensions().x() / 2; phigh[0] = Mbr.center().x() + Mbr.dimensions().x() / 2; plow[1] = Mbr.center().y() - Mbr.dimensions().y() / 2; phigh[1] = Mbr.center().y() + Mbr.dimensions().y() / 2; plow[2] = Mbr.center().z() - Mbr.dimensions().z() / 2; phigh[2] = Mbr.center().z() + Mbr.dimensions().z() / 2; SpatialIndex::Region mbr = SpatialIndex::Region(plow.data(),phigh.data(),3); std::stringstream strStream; strStream << s->id()<< "-" << j->id(); tree->insertData (strStream.str().length(), (byte*)(strStream.str().c_str()), mbr, segmentid); segmentid++; } } cout << ".. Total Segments: " << segmentid << "\n"; tree->~ISpatialIndex(); diskfile->~IStorageManager(); } // PRELOAD the Trees amd Neuron Morphology Mapping ISpatialIndex *neurons[NEURONS_COUNT]; global_transformer *transforms[NEURONS_COUNT]; int cm=0; int cn=0; string baseName = ""; Morphologies & myMorphologies = microcircuit.morphologies(); Neurons & myNeurons = microcircuit.neurons(); cout << "PreLoading Mappings \n"; Morphologies::iterator myMorphologiesEnd = myMorphologies.end(); for (Morphologies::iterator m = myMorphologies.begin(); m != myMorphologiesEnd; ++m) { baseName = m->label(); m-> IStorageManager* diskfile = StorageManager::loadDiskStorageManager(baseName); trees[cm] = RTree::loadRTree(*diskfile, 1); std::cout << "Checking R-tree structure... "; if (!trees[cm]->isIndexValid()) std::cerr << "R-tree internal checks failed!\n"; else std::cout << "OK\n"; IStatistics * tree_stats; trees[cm]->getStatistics (&tree_stats); cout << *tree_stats; Neurons::iterator myNeuronsEnd = myNeurons.end(); for (Neurons::iterator n = myNeurons.begin(); n != myNeuronsEnd; ++n) { if (strcmp(n->morphology().label().c_str(),m->label().c_str())==0) { transforms[cn] = n->global_transform().inverse(); neurons[cn] = trees[cm]; } cn++; if (cn>=NEURONS_COUNT) break; } cn=0;cm++; } /* * Query the Index */ }
int main(int argc, char **argv) { int airavata_port, airavata_timeout; string airavata_server; char* cfgfile; cfgfile = "./airavata-client-properties.ini"; readConfigFile(cfgfile, airavata_server, airavata_port, airavata_timeout); airavata_server.erase(0,1); airavata_server.erase(airavata_server.length()-1,1); boost::shared_ptr<TSocket> socket(new TSocket(airavata_server, airavata_port)); socket->setSendTimeout(airavata_timeout); boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket)); boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport)); AiravataClient airavataclient(protocol); transport->open(); if(argc !=4){ cout << "Usage: ./createExperiment <username> <experiment_name> <project_ID>"; return 0; } /* ComputationalResourceScheduling data for Trestles*/ ComputationalResourceScheduling cmRST; cmRST.__set_resourceHostId("trestles.sdsc.edu"); cmRST.__set_computationalProjectAccount("sds128"); cmRST.__set_totalCPUCount(1); cmRST.__set_nodeCount(1); cmRST.__set_numberOfThreads(0); cmRST.__set_queueName("normal"); cmRST.__set_wallTimeLimit(15); cmRST.__set_jobStartTime(0); cmRST.__set_totalPhysicalMemory(0); UserConfigurationData userConfigurationData; userConfigurationData.__set_airavataAutoSchedule(0); userConfigurationData.__set_overrideManualScheduledParams(0); userConfigurationData.__set_computationalResourceScheduling(cmRST); /*Application ID for Trestles */ char* appId = "SimpleEcho2"; /* Experiment input and output data. */ DataObjectType input; input.__set_key("echo_input"); input.__set_value("echo_output=Hello World"); input.__set_type(DataType::STRING); std::vector<DataObjectType> exInputs; exInputs.push_back(input); DataObjectType output; output.__set_key("echo_output"); output.__set_value(""); output.__set_type(DataType::STRING); std::vector<DataObjectType> exOutputs; exOutputs.push_back(output); char* user = argv[1]; char* exp_name = argv[2]; char* proj = argv[3]; Experiment experiment; experiment.__set_projectID(proj); experiment.__set_userName(user); experiment.__set_name(exp_name); experiment.__set_applicationId(appId); experiment.__set_userConfigurationData(userConfigurationData); experiment.__set_experimentInputs(exInputs); experiment.__set_experimentOutputs(exOutputs); string _return = ""; airavataclient.createExperiment(_return, experiment); if (_return!="") { cout << "Experiment " << _return <<" created! \n "; } else { cout << "Failed to create experiment. \n"; } transport->close(); }
int main(int argc, const char* argv[]) { const URI blue_config_filename(argv[1]); try { // LOADING CURCUIT Experiment experiment; experiment.open(blue_config_filename); Microcircuit & microcircuit = experiment.microcircuit(); const Targets & targets = experiment.targets(); const Cell_Target target = targets.cell_target("Column"); microcircuit.load(target, NEURONS | MORPHOLOGIES); // PRELOAD the Trees amd Neuron Morphology Mapping ISpatialIndex *trees[MORPHOLOGIES_COUNT]; ISpatialIndex *neurons[NEURONS_COUNT]; global_transformer *transforms[NEURONS_COUNT]; int cm=0; int cn=0; string baseName = ""; Morphologies & myMorphologies = microcircuit.morphologies(); Neurons & myNeurons = microcircuit.neurons(); cout << "PreLoading Mappings \n"; Morphologies::iterator myMorphologiesEnd = myMorphologies.end(); for (Morphologies::iterator m = myMorphologies.begin(); m != myMorphologiesEnd; ++m) { baseName = m->label(); IStorageManager* diskfile = StorageManager::loadDiskStorageManager(baseName); trees[cm] = RTree::loadRTree(*diskfile, 1); std::cout << "Checking R-tree structure... "; if (!trees[cm]->isIndexValid()) std::cerr << "R-tree internal checks failed!\n"; else std::cout << "OK\n"; IStatistics * tree_stats; trees[cm]->getStatistics (&tree_stats); cout << *tree_stats; Neurons::iterator myNeuronsEnd = myNeurons.end(); for (Neurons::iterator n = myNeurons.begin(); n != myNeuronsEnd; ++n) { if (strcmp(n->morphology().label().c_str(),m->label().c_str())==0) { transforms[cn] = n->global_transform().inverse(); neurons[cn] = trees[cm]; } cn++; if (cn>=NEURONS_COUNT) break; } cn=0;cm++; } /* // SINGLE QUERY cout << "Start Querying \n"; range_query_visitor visitor; SpatialIndex::Region query; micron_vector plow,phigh; plow[0] = 0; plow[1] = 0; plow[2] = 0; phigh[0]=90; phigh[1]=90; phigh[2]=90; for (int i=0;i<NEURONS_COUNT;i++) { get_transformed_cube_mbr(plow,phigh,*transforms[i],&query); neurons[i]->intersectsWithQuery(query,visitor); visitor.inc_neuron(); } visitor.print_stats(); */ // PERFORMANCE EVALUATION RANDOM RANGE QUERIES { cout << "Start Range Query Analysis \n"; range_query_visitor visitor; double plow[3],phigh[3]; plow[0] = 98.2538; plow[1] = 1005.14; plow[2] = 92.9046; phigh[0] = 452.301; phigh[1] = 1385.56; phigh[2] = 456.743; //plow[0] = -1698.38; plow[1] = -1065.03; plow[2] = -1724.75; // phigh[0] = 2248.56; phigh[1]= 1894.28; phigh[2]= 2276.71; SpatialIndex::Region query_region = SpatialIndex::Region(plow,phigh,3); boost::mt11213b generator (42u); const double x[3] = {0.0, 0.0, 0.0}; SpatialIndex::Point rnd_point1 (x, query_region.m_dimension); SpatialIndex::Point rnd_point2 (x, query_region.m_dimension); SpatialIndex::Region query; for (int j=0;j<QUERIES_FOR_ANALYSIS;j++) { for (size_t i = 0; i < query_region.m_dimension; i++) { boost::uniform_real<> uni_dist (query_region.m_pLow[i],query_region.m_pHigh[i]); boost::variate_generator<boost::mt11213b &,boost::uniform_real<> > uni(generator, uni_dist); rnd_point1.m_pCoords[i] = uni(); boost::uniform_real<> uni_dist1 (rnd_point1.m_pCoords[i],query_region.m_pHigh[i]); boost::variate_generator<boost::mt11213b &,boost::uniform_real<> > uni1(generator, uni_dist1); rnd_point2.m_pCoords[i] = uni1(); } visitor.new_query(); visitor.reset_neuron(); for (int i=0;i<NEURONS_COUNT;i++) { Vector_3D<Micron> low = Vector_3D<Micron>((Micron)rnd_point1.m_pCoords[0],(Micron)rnd_point1.m_pCoords[1],(Micron)rnd_point1.m_pCoords[2]); Vector_3D<Micron> high = Vector_3D<Micron>((Micron)rnd_point2.m_pCoords[0],(Micron)rnd_point2.m_pCoords[1],(Micron)rnd_point2.m_pCoords[2]); get_transformed_cube_mbr(low,high,*transforms[i],&query); neurons[i]->intersectsWithQuery(query,visitor); } if (j%100==0) cout << "Queries Done: " << j << "\n"; } visitor.print_stats(); } /* { // PERFORMANCE EVALUATION RANDOM POINT QUERIES cout << "Start Point Query Analysis \n"; range_query_visitor visitor; double plow[3],phigh[3]; //plow[0] = 98.2538; plow[1] = 1005.14; plow[2] = 92.9046; // phigh[0] = 452.301; phigh[1] = 1385.56; phigh[2] = 456.743; plow[0] = -1698.38; plow[1] = -1065.03; plow[2] = -1724.75; phigh[0] = 2248.56; phigh[1]= 1894.28; phigh[2]= 2276.71; SpatialIndex::Region query_region = SpatialIndex::Region(plow,phigh,3); boost::mt11213b generator (42u); for (int j=0;j<QUERIES_FOR_ANALYSIS;j++) { const double x[3] = {0.0, 0.0, 0.0}; SpatialIndex::Point rnd_point (x, query_region.m_dimension); SpatialIndex::Point tmp_point (x, query_region.m_dimension); for (size_t i = 0; i < query_region.m_dimension; i++) { boost::uniform_real<> uni_dist (query_region.m_pLow[i],query_region.m_pHigh[i]); boost::variate_generator<boost::mt11213b &,boost::uniform_real<> > uni(generator, uni_dist); rnd_point.m_pCoords[i] = uni(); } visitor.new_query(); visitor.reset_neuron(); //visitor.reset_stats(); for (int i=0;i<NEURONS_COUNT;i++) { // cout << "Point Query: (" << rnd_point.m_pCoords[0] << "," << rnd_point.m_pCoords[1] << "," << rnd_point.m_pCoords[2] << ") Transformed to: ("; Vector_3D<Micron> v = Vector_3D<Micron>((Micron)rnd_point.m_pCoords[0],(Micron)rnd_point.m_pCoords[1],(Micron)rnd_point.m_pCoords[2]); v = *transforms[i]*v; tmp_point.m_pCoords[0] = (double)v.x(); tmp_point.m_pCoords[1] = (double)v.y(); tmp_point.m_pCoords[2] = (double)v.z(); // cout << tmp_point.m_pCoords[0] << "," << tmp_point.m_pCoords[1] << "," << tmp_point.m_pCoords[2] << ")\n"; neurons[i]->pointLocationQuery(tmp_point,visitor); } } visitor.print_stats(); } */ // PERFORMANCE EVALUATION RANDOM RANGE QUERIES } catch (Tools::Exception& e) { cout << e.what() << endl; exit(0); } // delete tree_stats; return 0; }
void Viewer::init(){ int type,device; long document; bool okType=false, okDevice=false, okDocument=false; /*Size of window * The size of window has an initial value for unsupported screens and fullScreen * for the rest. * **/ resize(STARTWIDTH,STARTHEIGHT); setFullScreen(true); //Select type of experiment. '1' for 2D, '2' for 3D qglviewer::AxisPlaneConstraint* constraint; constraint = new LocalConstraint(); if(type=='1'){ constraint->setRotationConstraintType(AxisPlaneConstraint::FORBIDDEN); }else{ constraint->setRotationConstraintType(AxisPlaneConstraint::FREE); } //Constraint the zoom constraint->setTranslationConstraintType(AxisPlaneConstraint::FORBIDDEN); camera()->frame()->setConstraint(constraint); showEntireScene(); //Inicialization vars countMessages=0; addMessage("Inicializando Viewer ",0,9); //Ask for user data while(!okType){ type=QInputDialog::getInt (this, tr("Type of experiment"), tr("Select the type of experiment:" "\n 1. Pointing experiment" "\n 2. 3D drag and drop"), 1,1,2,1,&okType); } while(!okDevice){ device=QInputDialog::getInt (this, tr("Device to test"), tr("Select the device for the experiment:" "\n 1. Mouse" "\n 2. Wiimote" "\n 3. Kinect" "\n 4. Falcon"), 4,1,4,1,&okDevice); } while(!okDocument){ document=QInputDialog::getInt (this, tr("Document of the participant"), tr("Type the document of the participant"), 0,0,2147483647,1,&okDocument); } if(type==1){ //Experiment inicialization exper.init(width(),height(),device,document,BLOCKS_PER_EXPERIMENT,TRIALS_PER_ID); // Click on the right button to make a selection setMouseBinding(Qt::LeftButton,SELECT); falcon.init(width(),height()); falcon.addOptions(FalconMouse::DEVICE_OPTIONS | FalconMouse::COMM_OPTIONS | FalconMouse::FIRMWARE_OPTIONS); startAnimation(); }else{ QMessageBox::information(this, "Under construction", "The 3D experiment is under construction"); init(); } }
// Compare: // * 10 N memory // * 1...10 regular lookups // * 1...9 random lookups with and without BPMX // Only compare on longest problems void RunExperiments5(ScenarioLoader *sl) { std::vector<graphState> aPath; Map *m = new Map(sl->GetNthExperiment(0).GetMapName()); m->Scale(sl->GetNthExperiment(0).GetXScale(), sl->GetNthExperiment(0).GetYScale()); Graph *g = GraphSearchConstants::GetGraph(m); GraphMapInconsistentHeuristic diffHeuristic(m, g); diffHeuristic.SetPlacement(kAvoidPlacement); diffHeuristic.SetMode(kRandom); GraphEnvironment gEnv(g, &diffHeuristic); gEnv.SetDirected(true); TemplateAStar<graphState, graphMove, GraphEnvironment> taNew; Timer t; for (int x = 0; x < 10; x++) diffHeuristic.AddHeuristic(); //diffHeuristic.SetNumUsedHeuristics(diffHeuristic.GetNumHeuristics()/10); for (int x = 0; x < sl->GetNumExperiments(); x++) { Experiment e = sl->GetNthExperiment(x); if (e.GetBucket() != 127) continue; graphState start, goal; start = m->GetNodeNum(e.GetStartX(), e.GetStartY()); goal = m->GetNodeNum(e.GetGoalX(), e.GetGoalY()); printf("%d\t", e.GetBucket()); for (int y = 1; y <= 10; y++) { // N memory -- 1 heuristic diffHeuristic.SetNumUsedHeuristics(y); diffHeuristic.SetMode(kMax); taNew.SetUseBPMX(0); t.StartTimer(); taNew.GetPath(&gEnv, start, goal, aPath); t.EndTimer(); printf("%dmx\t%lld\t%f\t%f\t", diffHeuristic.GetNumUsedHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime(), gEnv.GetPathLength(aPath)); } for (int y = 1; y <= 9; y++) { for (int z = 0; z <= 1; z++) { // N memory -- 1 heuristic diffHeuristic.SetNumUsedHeuristics(y); diffHeuristic.SetMode(kRandom); taNew.SetUseBPMX(z); t.StartTimer(); taNew.GetPath(&gEnv, start, goal, aPath); t.EndTimer(); if (z==0) printf("%drnd\t%lld\t%f\t%f\t", diffHeuristic.GetNumUsedHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime(), gEnv.GetPathLength(aPath)); else printf("%drdb\t%lld\t%f\t%f\t", diffHeuristic.GetNumUsedHeuristics(), taNew.GetNodesExpanded(), t.GetElapsedTime(), gEnv.GetPathLength(aPath)); } } printf("\n"); } exit(0); }