TEST(SFM_DATA_FILTERS, LargestViewTrackCC) { // Init a scene with 5 Views & poses SfM_Data sfm_data; init_scene(sfm_data, 5); // Fill with some tracks // //- View 0,1,2 are sharing 3 tracks // TrackId 0 -> 0-1-2 // TrackId 1 -> 0-1-2 // TrackId 2 -> 0-1-2 // // While view 3-4 are sharing 1 track // TrackId 3 -> 3-4 Observations obs; obs[0] = Observation( Vec2(10,20), 0); obs[1] = Observation( Vec2(30,10), 1); obs[2] = Observation( Vec2(30,10), 1); sfm_data.structure[0].obs = obs; sfm_data.structure[0].X = Vec3::Random(); sfm_data.structure[1].obs = obs; sfm_data.structure[1].X = Vec3::Random(); sfm_data.structure[2].obs = obs; sfm_data.structure[2].X = Vec3::Random(); obs.clear(); obs[3] = Observation( Vec2(10,20), 0); obs[4] = Observation( Vec2(10,20), 0); sfm_data.structure[3].obs = obs; sfm_data.structure[3].X = Vec3::Random(); // Track of the SfM_Data scene contains two connected component // One for view (0,1,2) // One for the view (3,4) // Test that function to keep the largest one is working EXPECT_EQ (4, sfm_data.GetLandmarks().size()); EXPECT_FALSE (IsTracksOneCC(sfm_data)); KeepLargestViewCCTracks(sfm_data); EXPECT_EQ (3, sfm_data.GetLandmarks().size()); }
int YAMRSlave::run_model(Parameters &pars, Observations &obs) { int success = 1; //bool isDouble = true; //bool forceRadix = true; //TemplateFiles tpl_files(isDouble,forceRadix,tplfile_vec,inpfile_vec,par_name_vec); //InstructionFiles ins_files(insfile_vec,outfile_vec,obs_name_vec); std::vector<double> obs_vec; try { // message.str(""); int ifail; int ntpl = tplfile_vec.size(); int npar = pars.size(); vector<string> par_name_vec; vector<double> par_values; for(auto &i : pars) { par_name_vec.push_back(i.first); par_values.push_back(i.second); } wrttpl_(&ntpl, StringvecFortranCharArray(tplfile_vec, 50).get_prt(), StringvecFortranCharArray(inpfile_vec, 50).get_prt(), &npar, StringvecFortranCharArray(par_name_vec, 50, pest_utils::TO_LOWER).get_prt(), par_values.data(), &ifail); if(ifail != 0) { throw PestError("Error processing template file:" + tpl_err_msg(ifail)); } //tpl_files.writtpl(par_values); // update parameter values pars.clear(); for (int i=0; i<npar; ++i) { pars[par_name_vec[i]] = par_values[i]; } // run model for (auto &i : comline_vec) { ifail = system(i.c_str()); if(ifail != 0) { cerr << "Error executing command line: " << i << endl; throw PestError("Error executing command line: " + i); } } // process instructio files int nins = insfile_vec.size(); int nobs = obs_name_vec.size(); std::vector<double> obs_vec; obs_vec.resize(nobs, -9999.00); readins_(&nins, StringvecFortranCharArray(insfile_vec, 50).get_prt(), StringvecFortranCharArray(outfile_vec, 50).get_prt(), &nobs, StringvecFortranCharArray(obs_name_vec, 50, pest_utils::TO_LOWER).get_prt(), obs_vec.data(), &ifail); if(ifail != 0) { throw PestError("Error processing template file"); } //obs_vec = ins_files.readins(); // check parameters and observations for inf and nan if (std::any_of(par_values.begin(), par_values.end(), OperSys::double_is_invalid)) { throw PestError("Error running model: invalid parameter value returned"); } if (std::any_of(obs_vec.begin(), obs_vec.end(), OperSys::double_is_invalid)) { throw PestError("Error running model: invalid observation value returned"); } // update observation values obs.clear(); for (int i=0; i<nobs; ++i) { obs[obs_name_vec[i]] = obs_vec[i]; } } catch(const std::exception& ex) { cerr << endl; cerr << " " << ex.what() << endl; cerr << " Aborting model run" << endl << endl; success = 0; } catch(...) { cerr << " Error running model" << endl; cerr << " Aborting model run" << endl; success = 0; } return success; }
void RunManagerSerial::run() { int ifail; int success_runs = 0; int prev_sucess_runs = 0; const vector<string> &par_name_vec = file_stor.get_par_name_vec(); const vector<string> &obs_name_vec = file_stor.get_obs_name_vec(); int npar = par_name_vec.size(); int nobs = obs_name_vec.size(); int ntpl = tplfile_vec.size(); int nins = insfile_vec.size(); stringstream message; bool isDouble = true; bool forceRadix = true; //TemplateFiles tpl_files(isDouble, forceRadix, tplfile_vec, inpfile_vec, par_name_vec); //InstructionFiles ins_files(insfile_vec, outfile_vec); std::vector<double> obs_vec; // This is necessary to support restart as some run many already be complete vector<int> run_id_vec; int nruns = get_outstanding_run_ids().size(); while (!(run_id_vec = get_outstanding_run_ids()).empty()) { for (int i_run : run_id_vec) { //first delete any existing input and output files for (auto &out_file : outfile_vec) { if((check_exist_out(out_file)) && (remove(out_file.c_str()) != 0)) throw PestError("model interface error: Cannot delete existing model output file "+out_file); } for (auto &in_file : inpfile_vec) { if ((check_exist_out(in_file)) && (remove(in_file.c_str()) != 0)) throw PestError("model interface error: Cannot delete existing model input file " + in_file); } Observations obs; vector<double> par_values; Parameters pars; file_stor.get_parameters(i_run, pars); try { std::cout << string(message.str().size(), '\b'); message.str(""); message << "(" << success_runs << "/" << nruns << " runs complete)"; std::cout << message.str(); OperSys::chdir(run_dir.c_str()); for (auto &i : par_name_vec) { par_values.push_back(pars.get_rec(i)); } if (std::any_of(par_values.begin(), par_values.end(), OperSys::double_is_invalid)) { throw PestError("Error running model: invalid parameter value returned"); } wrttpl_(&ntpl, StringvecFortranCharArray(tplfile_vec, 50).get_prt(), StringvecFortranCharArray(inpfile_vec, 50).get_prt(), &npar, StringvecFortranCharArray(par_name_vec, 50, pest_utils::TO_LOWER).get_prt(), &par_values[0], &ifail); if (ifail != 0) { throw PestError("Error processing template file"); } for (int i = 0, n_exec = comline_vec.size(); i < n_exec; ++i) { system(comline_vec[i].c_str()); } obs_vec.resize(nobs, RunStorage::no_data); readins_(&nins, StringvecFortranCharArray(insfile_vec, 50).get_prt(), StringvecFortranCharArray(outfile_vec, 50).get_prt(), &nobs, StringvecFortranCharArray(obs_name_vec, 50, pest_utils::TO_LOWER).get_prt(), &obs_vec[0], &ifail); if (ifail != 0) { throw PestError("Error processing instruction file"); } // check parameters and observations for inf and nan if (std::any_of(par_values.begin(), par_values.end(), OperSys::double_is_invalid)) { throw PestError("Error running model: invalid parameter value returned"); } if (std::any_of(obs_vec.begin(), obs_vec.end(), OperSys::double_is_invalid)) { throw PestError("Error running model: invalid observation value returned"); } /* // IOPP version for (int i = 0, n_exec = comline_vec.size(); i < n_exec; ++i) { system(comline_vec[i].c_str()); } //pest_utils::thread_flag* tf1(false); //pest_utils::thread_flag* tf2(false); //w_run_commands(tf1,tf2,comline_vec); ins_files.read(obs_name_vec, obs); */ success_runs += 1; pars.clear(); pars.insert(par_name_vec, par_values); obs.clear(); obs.insert(obs_name_vec, obs_vec); file_stor.update_run(i_run, pars, obs); } catch (const std::exception& ex) { file_stor.update_run_failed(i_run); cerr << endl; cerr << " " << ex.what() << endl; cerr << " Aborting model run" << endl << endl; } catch (...) { file_stor.update_run_failed(i_run); cerr << endl; cerr << " Error running model" << endl; cerr << " Aborting model run" << endl << endl; } } } total_runs += success_runs; std::cout << string(message.str().size(), '\b'); message.str(""); message << "(" << success_runs << "/" << nruns << " runs complete"; if (prev_sucess_runs > 0) { message << " and " << prev_sucess_runs << " additional run completed previously"; } message << ")"; std::cout << message.str(); if (success_runs < nruns) { cout << endl << endl; cout << "WARNING: " << nruns - success_runs << " out of " << nruns << " runs failed" << endl << endl; } std::cout << endl << endl; }
void RunManagerGenie::run() { int nexec = comline_vec.size(); const vector<string> &par_name_vec = file_stor.get_par_name_vec(); const vector<string> &obs_name_vec = file_stor.get_obs_name_vec(); int npar = par_name_vec.size(); int nobs = obs_name_vec.size(); int ntpl = tplfile_vec.size(); int nins = insfile_vec.size(); stringstream apar; stringstream aobs; stringstream execnames; stringstream tplfle; stringstream infle; stringstream insfle; stringstream outfle; vector<double> par_val; vector<double> obs_val; vector<int> ifail; // This is necessary to support restart as some run many already be complete vector<int> run_id_vec = get_outstanding_run_ids(); int nruns = run_id_vec.size(); par_val.clear(); obs_val.resize(nruns*nobs); ifail.resize(nruns); for (int i_run : run_id_vec) { Parameters tmp_pars; file_stor.get_parameters(i_run, tmp_pars); vector<double> tmp_vec = tmp_pars.get_data_vec(par_name_vec); par_val.insert(par_val.end(), tmp_vec.begin(), tmp_vec.end()); } vector<string> par_name_vec_lwr = par_name_vec; for (auto &ipar : par_name_vec_lwr) { lower_ip(ipar); } vector<string> obs_name_vec_lwr = obs_name_vec; for (auto &iobs : obs_name_vec_lwr) { lower_ip(iobs); } std::copy(par_name_vec_lwr.begin(), par_name_vec_lwr.end(),std::ostream_iterator<std::string>(apar,"\n")); std::copy(obs_name_vec_lwr.begin(), obs_name_vec_lwr.end(),std::ostream_iterator<std::string>(aobs,"\n")); std::copy(comline_vec.begin(), comline_vec.end(),std::ostream_iterator<std::string>(execnames,"\n")); std::copy(tplfile_vec.begin(), tplfile_vec.end(),std::ostream_iterator<std::string>(tplfle,"\n")); std::copy(inpfile_vec.begin(), inpfile_vec.end(),std::ostream_iterator<std::string>(infle,"\n")); std::copy(insfile_vec.begin(), insfile_vec.end(),std::ostream_iterator<std::string>(insfle,"\n")); std::copy(outfile_vec.begin(), outfile_vec.end(),std::ostream_iterator<std::string>(outfle,"\n")); #ifdef OS_WIN GENIE_INTERFACE(&nruns, &nexec, String2CharPtr(execnames.str()).get_char_ptr(), &npar, &nobs, String2CharPtr(apar.str()).get_char_ptr(), String2CharPtr(aobs.str()).get_char_ptr(), &par_val[0], &obs_val[0], &ntpl, &nins, String2CharPtr(tplfle.str()).get_char_ptr(), String2CharPtr(infle.str()).get_char_ptr(), String2CharPtr(insfle.str()).get_char_ptr(), String2CharPtr(outfle.str()).get_char_ptr(), String2CharPtr(host).get_char_ptr(), String2CharPtr(id).get_char_ptr(), &ifail[0]); #endif #ifdef OS_LINUX throw(PestError("Error: Genie run manager is not supported under linux")); #endif total_runs += nruns; Parameters pars; Observations obs; for (int i=0; i<nruns; ++i) { if (ifail[i] == 0) { int run_id = run_id_vec[i]; pars.clear(); vector<double> i_par_vec(par_val.begin() + i*npar, par_val.begin() + (i + 1)*npar); pars.insert(par_name_vec, i_par_vec); obs.clear(); vector<double> i_obs_vec(obs_val.begin() + i*nobs, obs_val.begin() + (i + 1)*nobs); obs.insert(obs_name_vec, i_obs_vec); file_stor.update_run(run_id, pars, obs); } else { file_stor.set_run_nfailed(i, max_n_failure); } } }