/** * Parses command line arguments in this library's format. Will exit if help is * called. * * @param[in] argc * @param[in] argv * @param[out] mdp_paths POMDP config file paths read from arguments. * @param[out] policy_paths Policy config file paths read from flags. * @param[out] learning_paths Learning config file paths read from flags. * @return True on success. * * @todo Parse flags as well, perhaps using optional arguments. */ bool parseArgs(int argc, char* argv[], std::vector<std::string>& mdp_paths, std::vector<std::string>& policy_paths, std::vector<std::string>& learning_paths) { // Flags (e.g. --help or -h) namespace bargs = boost::program_options; std::string usage = "USAGE: " + boost::filesystem::path(argv[0]).stem().string() + " POMDP_FILE...\nAllowed options"; bargs::options_description op_desc(usage.c_str()); op_desc.add_options() ("help,h", "Display this help message") ("POMDP_FILE", bargs::value<std::vector<std::string> >(&mdp_paths), "Path to each POMDP config file.") ("policy,p", bargs::value<std::vector<std::string> >(&policy_paths), "Path to each policy config file.") ("learn,l", bargs::value<std::vector<std::string> >(&learning_paths), "Path to each learning config file.") ; // Positional arguments bargs::positional_options_description arg_desc; arg_desc.add("POMDP_FILE", -1); bargs::variables_map args_var_map; try { bargs::store(bargs::command_line_parser(argc, argv).options(op_desc) .positional(arg_desc).run(), args_var_map); bargs::notify(args_var_map); if(args_var_map.count("help") || argc == 1) { std::cout << op_desc << std::endl; exit(EXIT_SUCCESS); } } catch(bargs::error& err) { std::cerr << "ERROR: " << err.what() << std::endl << std::endl; std::cerr << op_desc << std::endl; return false; } return true; }
int main(int ac, char** av) { //Variables to be assigned by program options double height_map_resolution; double north_bound; double south_bound; double east_bound; double west_bound; int sun_angles; int times_per_year; int start_day; double summer_angle_panel; double winter_angle_panel; bool use_terrain_normals = true; bool compute_best_fixed_angle = false; bool compute_best_summer_winter_angle = false; std::string input_file; std::string output_file; bool verbose = false; bool elevation_dependant_sun_intensity = false; // Declare the supported options. po::options_description op_desc("Allowed options"); op_desc.add_options() ("help", "print options table") ("input-file,i", po::value<std::string>(&input_file), "File containing height map data in x<space>y<space>z<newline> swiss coordinates format") ("output-file-base,o", po::value<std::string>(&output_file)->default_value("data_out"), "Base filname for output files (default data_out)") ("resolution,R", po::value<double>(&height_map_resolution)->default_value(200.0), "resolution of data (default: 200.0)") ("nmax",po::value<double>(&north_bound)->default_value(1e100), "maximum north coordinate to be treated (default 1e100)") ("nmin",po::value<double>(&south_bound)->default_value(-1e100), "minimum north coordinate to be treated (default -1e100)") ("emax",po::value<double>(&east_bound)->default_value(1e100), "maximum east coordinate to be treated (default 1e100)") ("emin",po::value<double>(&west_bound)->default_value(-1e100), "minimum east coordinate to be treated (default -1e100)") ("elevation,E", "Include effect of terrain elevation in the computation of sun intensity") ("sunangles,s", po::value<int>(&sun_angles)->default_value(360), "number of angles to compute sunlight from (default 360)") ("times,t", po::value<int>(×_per_year)->default_value(12), "number of times per year to calculate at (default 12)") ("start-day, D", po::value<int>(&start_day)->default_value(20), "Day of the year to output first data. (default 20)") ("fixed-angle, F", po::value<double>(&summer_angle_panel), "Use fixed angle for solar panel inclination to compute sun intensity.") ("summer-angle", po::value<double>(&summer_angle_panel), "Fixed angle for solar panel inclination during summer to compute sun intensity..") ("winter-angle", po::value<double>(&winter_angle_panel), "Fixed angle for solar panel inclination during winter to compute sun intensity..") ("best-fixed-angle, B", "Use best fixed angle for this latitude to compute sun intensity.") ("best-two-season-angles, BSW", "Use best summer and winter angle for this latitude to compute sun intensity.") ("terrain-normals, T", "Use terrain normal for each point to compute sun intensity, default option if none of the solar panel angles options are specified.") ("verbose, v", "Verbose: output lots of text") ; po::positional_options_description pd; pd.add("input-file", 1).add("output-file", 1); po::variables_map vm; po::store(po::parse_command_line(ac, av, op_desc), vm); po::notify(vm); if (vm.count("help")) { std::cout <<"CrunchGeoData [options] [input file] [output base]"<<std::endl<< op_desc << std::endl; return 1; } if(vm.count("fixed-angle")){ winter_angle_panel = summer_angle_panel; use_terrain_normals = false; } if(vm.count("summer-angle") && !vm.count("winter-angle")){ std::cout << "Please specify also a winter angle, or use option fixed-angle" << std::endl; exit(255); } if(vm.count("best-fixed-angle")){ use_terrain_normals = false; compute_best_fixed_angle = true; } if(vm.count("best-two-season-angles")){ use_terrain_normals = false; compute_best_summer_winter_angle = true; } if (vm.count("elevation")){ elevation_dependant_sun_intensity = true; } if (vm.count("verbose")){ verbose = true; } if(!vm.count("input-file")){ std::cout << "Input file must be specified" << std::endl; exit(255); } std::unordered_map<vector3d, std::vector<double>, hash> grid_points; //grid_points is unordered_map of all points in bounding box with //a vector to hold average sun power for the days sun is computed double north_x_max; double east_y_max; double south_x_min; double west_y_min; import_heightmap(input_file, south_bound, north_bound, east_bound, west_bound, times_per_year, grid_points ,north_x_max, south_x_min, east_y_max, west_y_min); std::pair<double,double> NE = swiss_to_lat_lon(north_x_max+height_map_resolution/2.0, east_y_max+height_map_resolution/2.0); std::pair<double,double> SW = swiss_to_lat_lon(south_x_min-height_map_resolution/2.0, west_y_min-height_map_resolution/2.0); std::cout << "NE: " << north_x_max <<", " << east_y_max << " SW: "<< south_x_min << " , " << west_y_min << std::endl; std::cout << std::setprecision(9) << "NE: " << NE.first <<", " << NE.second << " SW: "<< SW.first << ", " << SW.second << std::endl; std::cout << "Number of points in dataset: " << grid_points.size() << std::endl; double average_latitude=((NE.first+SW.first)/2.0)*M_PI/180.0; vector3d summer_normal_panel; vector3d winter_normal_panel; if(!use_terrain_normals){ if(compute_best_fixed_angle){ } if(compute_best_summer_winter_angle){ } if(average_latitude > 0){ //if latitude is greater than zero, point south summer_normal_panel.x = -1*sin(summer_angle_panel*M_PI/180); summer_normal_panel.y = 0; summer_normal_panel.z = 1*cos(summer_angle_panel*M_PI/180); winter_normal_panel.x = -1*sin(winter_angle_panel*M_PI/180); winter_normal_panel.y = 0; winter_normal_panel.z = 1*cos(winter_angle_panel*M_PI/180); } else{ //if latitude is less than zero, point north summer_normal_panel.x = 1*sin(summer_angle_panel*M_PI/180); summer_normal_panel.y = 0; summer_normal_panel.z = 1*cos(summer_angle_panel*M_PI/180); winter_normal_panel.x = 1*sin(winter_angle_panel*M_PI/180); winter_normal_panel.y = 0; winter_normal_panel.z = 1*cos(winter_angle_panel*M_PI/180); } } std::vector<std::vector<double> > sun_elevation_angle(times_per_year,std::vector<double>(sun_angles)); //Elevation angle PHI of sun for a day and hour std::vector<std::vector<double> > sun_intensity_day_angle(times_per_year,std::vector<double>(sun_angles)); std::vector<std::vector <vector3d> > sun_vec_day_angle(times_per_year,std::vector<vector3d>(sun_angles)); //Unit vectors for sun's direction in day, hour. for(int day = 0; day < times_per_year; day++){ double N=(365.0*day)/times_per_year+start_day; //We are computing values for the Nth day of the year double phi_axis=-asin(0.39779*cos((0.98565*(N+10)+1.914*sin(0.98565*(N-2)*M_PI/180))*M_PI/180)); //Earth axis inclination for day N for(int thH=0;thH<sun_angles;thH++){//Angle theta for sun; 0 is North, +90 is West. int indTH= thH; double thHrad = (180-thH)*M_PI/180.0; //turn around for sun formula angle double phiElv=asin(sin(average_latitude)*sin(phi_axis)+cos(average_latitude)*cos(thHrad)*cos(phi_axis)); //Sun elevation, imperical fomula, see wikipedia thHrad = M_PI-thHrad; //In our coordinate system (North x+, West y+) we must inverse the sun theta. Theta corresponds to sun ray direction. vector3d sun_vec(cos(phiElv) * cos(thHrad) , cos(phiElv) * sin(thHrad) , sin(phiElv)); //Unit vector for direction sun ray come from sun_elevation_angle[(int)day][indTH]=phiElv; //stick sun elevation in its datastructure sun_vec_day_angle[(int)day][indTH]=sun_vec; //stick sun vector in its datastructure double air_mass_coefficient =sqrt(708.0*708.0*sin(phiElv)*sin(phiElv)+2.0*708.0+1.0)-708.0*sin(phiElv); //wikipedia sun_intensity_day_angle[(int)day][indTH]=pow(0.7,pow(air_mass_coefficient,0.678))/0.7; //stick sun intensity in its datastructure } } std::vector<double> max_sun_intensity; max_sun_intensity.assign(times_per_year, 0); std::vector<double> min_sun_intensity; min_sun_intensity.assign(times_per_year, 1e12); int N=0; std::cout <<" Progress: "<< 100*(N*1.0)/(grid_points.size()*1.0) <<" % \n"; for(auto grid_point : grid_points){ vector3d v = grid_point.first; N++; if (1) { std::cout <<" Progress: "<< 100.0*(N*1.0)/(grid_points.size()*1.0) <<" % ("<<N<<") \r"; std::cout.flush(); } vector3d vNx(v.x+height_map_resolution*10,v.y,0); //get points 10xresolution to the north, west, south and east vector3d vWx(v.x,v.y+height_map_resolution*10,0); vector3d vSx(v.x-height_map_resolution*10,v.y,0); vector3d vEx(v.x,v.y-height_map_resolution*10,0); auto itEx=grid_points.find(vEx); auto itNx=grid_points.find(vNx); auto itWx=grid_points.find(vWx); auto itSx=grid_points.find(vSx); if (itEx == grid_points.end()||itNx == grid_points.end()||itWx == grid_points.end()||itSx == grid_points.end()){ std::vector<double> L; L.assign(times_per_year,-1.0); //border points get value -1.0 to indicate we have coputed no value for them grid_points[v]=L; continue; } //v = *it_v; vector3d vN(v.x+height_map_resolution,v.y,0); //get points to the north, west, south and east vector3d vW(v.x,v.y+height_map_resolution,0); vector3d vS(v.x-height_map_resolution,v.y,0); vector3d vE(v.x,v.y-height_map_resolution,0); auto itE=grid_points.find(vE); auto itN=grid_points.find(vN); auto itW=grid_points.find(vW); auto itS=grid_points.find(vS); if (itE == grid_points.end()||itN == grid_points.end()||itW == grid_points.end()||itS == grid_points.end()){ exit(-1); } vE=itE->first; vN=itN->first; vW=itW->first; vS=itS->first; vector3d Normal = ((((vE-v)^(vN-v))+((vW-v)^(vS-v)))/2).norm(); //normal is the crossproduct of two prependicular differences. Avgd. std::vector<double> horizon_elevation_angles; //vector to hold elevation angles at theta horizon_elevation_angles.assign(sun_angles, 0); // std::vector<vector3d> horizon(sun_angles); std::vector<double> dists(sun_angles); size_t edge_points = 0; size_t interior_points = 0; for(int theta = 0; theta<sun_angles;theta++){ //compute for each angle theta double th = theta*M_PI/180; { double sin_theta = sin(th); //calculate sin of the angle in radians double yend = EQ_DBL(copysign(1,sin_theta),1)?east_y_max:0; //if the sinus is positive endvalue is east_y_max, if negative 0 for(double y=v.y+copysign(height_map_resolution,sin_theta);(y >= 0 && y <= east_y_max);y+=copysign(height_map_resolution,sin_theta)){//increase/decrease if theta +/- double x = v.x+(y-v.y)/tan(th); //find the x that goes with y for this theta double x1 = floor(x-((int)x%(int)height_map_resolution)); //find the nearest lower gridpoint by subtracting remainder according to height_map_resolution double x2 = x1 + height_map_resolution; //Add height_map_resolution to get nearest higher gridpoint double phi = horizon_elevation_angles[theta]; double dist = (v-vector3d(x,y,v.z)).length(); double phiMaxTheta = atan(5000.0/dist); //maximal phi at this theta (with height 5000 m) if(x1>=north_x_max||x1<0||x2>=north_x_max||x2<0||phi>phiMaxTheta){ break; } if((int)x%(int)height_map_resolution){ //if x is not a grid point auto it_vec1 = grid_points.find(vector3d(x1,y,0)); //get the two gridpoints from the set auto it_vec2 = grid_points.find(vector3d(x2,y,0)); if (it_vec1 == grid_points.end()||it_vec2 == grid_points.end()){ edge_points++; continue; } vector3d vec1 = it_vec1->first; vector3d vec2 = it_vec2->first; double height = vec1.z*(x2-x)/height_map_resolution + vec2.z*(x-x1)/height_map_resolution-v.z; //compute height at x via linear interpolation dist=(v-vector3d(x,y,v.z)).length(); phi = atan(height/dist); if(phi>horizon_elevation_angles[theta]){//see if larger horizon_elevation_angles[theta]=phi; dists[theta] = dist/1000; } } else{//if x is a gridpoint auto it_vec = grid_points.find(vector3d(x,y,0)); //get vector if (it_vec == grid_points.end()){ //exit(-1); edge_points++; continue; } vector3d vec = it_vec->first; double height = vec.z-v.z; //get height double dist=(v-vector3d(x,y,v.z)).length(); double phi = atan(height/dist); if(phi>horizon_elevation_angles[theta]){//see if larger horizon_elevation_angles[theta]=phi; dists[theta] = dist/1000; } } interior_points++; } } double cos_theta = cos(th); double xend = EQ_DBL(copysign(1,cos_theta),1)?north_x_max:0; //if the cosinus is positive endvalue is north_x_max, if negative 0 for(double x=v.x+copysign(height_map_resolution,cos_theta);(x >= 0 && x <= north_x_max);x+=copysign(height_map_resolution,cos_theta)){//increase/decrease if theta +/- double y = v.y+(x-v.x)*tan(th); //find the y that goes with x for this theta double y1 = floor(y-((int)y%(int)height_map_resolution)); //find the nearest lower gridpoint by subtracting remainder according to height_map_resolution double y2 = y1 + height_map_resolution; //Add height_map_resolution to get nearest higher gridpoint double phi = horizon_elevation_angles[theta]; double dist = sqrt((v.x-x)*(v.x-x) + (v.y-y)*(v.y-y)); double phiMaxTheta = atan(5000.0/dist); //maximal phi at this theta (with height 5000 m) if(y1>=north_x_max||y1<0||y2>=north_x_max||y2<0||phi>phiMaxTheta){ break; } if((int)y%(int)height_map_resolution){ //if y is not a grid point auto it_vec1 = grid_points.find(vector3d(x,y1,0)); //get the two gridpoints from the set auto it_vec2 = grid_points.find(vector3d(x,y2,0)); if (it_vec1 == grid_points.end()||it_vec2 == grid_points.end()){ //exit(-1); edge_points++; continue; } vector3d vec1 = it_vec1->first; vector3d vec2 = it_vec2->first; double height = vec1.z*(y2-y)/height_map_resolution + vec2.z*(y-y1)/height_map_resolution-v.z; //compute height at y via linear interpolation double dist=(v-vector3d(x,y,v.z)).length(); double phi = atan(height/dist); if(phi>horizon_elevation_angles[theta]){//see if larger horizon_elevation_angles[theta]=phi; dists[theta] = dist/1000; } } else{//if y is a gridpoint auto it_vec = grid_points.find(vector3d(x,y,0)); //get vector if (it_vec == grid_points.end()){ //exit(-1); edge_points++; continue; } vector3d vec = it_vec->first; double height = vec.z-v.z; //get height double dist=(v-vector3d(x,y,v.z)).length(); double phi = atan(height/dist); if(phi>horizon_elevation_angles[theta]){//see if larger horizon_elevation_angles[theta]=phi; dists[theta] = dist/1000; } } interior_points++; } } int k = 0; std::vector<double> average_sun_intensity; average_sun_intensity.assign(times_per_year, 0.0); double sun_intensity = 0; for(int j=0;j<times_per_year;j++){ for (k=0;k<sun_angles;k++) { if(horizon_elevation_angles[k]>sun_elevation_angle[j][k]){ sun_intensity=0; } else{ double height = 0; if(elevation_dependant_sun_intensity){ height = v.z; } //spherical shell approximation for air mass attenuation, see wikipedia // http://en.wikipedia.org/wiki/Air_mass_%28solar_energy%29 double phi = sun_elevation_angle[j][k]; double R_E = 6371000.0; //Earth radius, meters double y_atm = 9000.0; //Athmospheric thickness, meters double r = R_E/y_atm; double c = height/y_atm; double air_mass_coefficient = sqrt((r+c)*(r+c)*cos(phi)*cos(phi) + (2*r+1+c)*(1-c))-(r+c)*cos(phi); double I_0 = 1.353; // kW/m^2 double I = 1.1 * I_0 * pow(0.7, pow(air_mass_coefficient, 0.678)); sun_intensity = I * (sun_vec_day_angle[j][k] * Normal); average_sun_intensity[j]+=sun_intensity; } average_sun_intensity[j] = average_sun_intensity[j] / sun_angles; grid_point.second[j]=average_sun_intensity[j]; max_sun_intensity[j] = (average_sun_intensity[j] > max_sun_intensity[j])?average_sun_intensity[j]:max_sun_intensity[j]; min_sun_intensity[j] = (average_sun_intensity[j] < min_sun_intensity[j])?average_sun_intensity[j]:min_sun_intensity[j]; } assert(average_sun_intensity.size() == times_per_year); grid_points[v]=average_sun_intensity; assert(grid_point.second.size() == times_per_year); } } std::cout << grid_points.size() << std::endl; for(int k = 0; k < times_per_year; ++k){ std::ostringstream oss(""); oss << k; std::ofstream ofs(output_file + oss.str() + ".xyz"); if (!ofs.is_open()){ exit(-2); } for(auto grid_point : grid_points){ vector3d v = grid_point.first; if(grid_point.second.size()>k){ ofs << v.x << " " << v.y << " " << v.z << " "; ofs << grid_points[v][k] << std::endl; } } } return 0; }
int main(int argc, char** argv) { uint64_t cstart, cend; double cdiff; cstart = clock(); Configuration *conf; // TODO Check scfg creation and optimization, because edge types are changed in for jumps and calls from ForwardStep to ForwardJump, BackwardJump // TODO Documentation needed! (in main function and in all header files) program_options::options_description op_required("Required options"); op_required.add_options() ("config-file,c", program_options::value<string>(), "configuration file (required)") ; program_options::options_description op_basic(""); op_basic.add_options() ("help,h", "This help message") ("help-config", "Help message for the format of the configuration files.") ("help-architecture", "Help message for the format of the architecture files.") ("help-carcore", "Help message for the format of the CarCore config files.") ("help-armv6m", "Help message for the format of the ARMv6M config files.") ("help-flow-facts", "Help message for the format of the flow-fact files.") ("version,v", "version") ; program_options::options_description op_add("Additional parameters to overwrite/set specific config file settings"); op_add.add_options() ("set-arch-file,a", program_options::value<string>(), "set architectural configuration file") ("set-log-file,l", program_options::value<string>(), "set log output file") ("set-rpt-file,r", program_options::value<string>(), "set report file") ("set-log-dir,L", program_options::value<string>(), "set log output dir (parameter is added as prefix)") ("set-rpt-dir,R", program_options::value<string>(), "set report dir (parameter is added as prefix)") ("set-out-dir,D", program_options::value<string>(), "set log and report dir (parameter is added as prefix, do not use with -L or -R)") ; program_options::options_description op("All Options"); op.add(op_required).add(op_basic).add(op_add); stringstream s; s << endl << "Usage:\n" << argv[0] << " configs/config_file.cfg\n\nParameters"; program_options::options_description op_desc(s.str()); op_desc.add(op_basic).add(op_add); program_options::positional_options_description pos_op; pos_op.add("config-file", -1); program_options::variables_map vm; vector<string> wrong_parameters; try { // parse parameters program_options::parsed_options parsed_params = program_options::command_line_parser(argc, argv).options(op).positional(pos_op).allow_unregistered().run(); // propagate to variables_map program_options::store(parsed_params, vm); program_options::notify(vm); // check for wrong parameters wrong_parameters = collect_unrecognized(parsed_params.options, program_options::include_positional); } catch(program_options::ambiguous_option e) { cout << endl << "Wrong parameter: " << e.what() << endl; cout << op_desc << endl; exit(1); } if(wrong_parameters.size() != 0) { if (vm.count("config-file") && wrong_parameters.size()==1) { // Somehow the positional option is also recognized as unrecognized. // If the config file is the only unknown parameter, proceed with normal operation. goto read_config; } cout << "Wrong parameter(s): "; for(vector<string>::iterator it = wrong_parameters.begin(); it != wrong_parameters.end(); ++it) { cout << *it << " "; } cout << endl; cout << op_desc << endl; exit(1); } else if(vm.count("help")) { cout << op_desc << endl; exit(1); } else if(vm.count("help-config")) { cout << Configuration::getInstanceWithHelpMessages()->getHelpMessage() << endl; exit(1); } else if(vm.count("help-architecture")) { cout << ArchConfig::getBasicHelpMessage() << endl; exit(1); } else if(vm.count("help-carcore")) { cout << CarCoreConfig::getInstanceWithHelpMessages()->getHelpMessage() << endl; exit(1); } else if(vm.count("help-armv6m")) { cout << Armv6mConfig::getInstanceWithHelpMessages()->getHelpMessage() << endl; exit(1); } else if(vm.count("help-flow-facts")) { cout << FlowFactReader::getHelpMessage() << endl; cout << CallTargetExtractor::getHelpMessage() << endl; cout << JumpTargetExtractor::getHelpMessage() << endl; exit(1); } else if(vm.count("version")) { printVersion(); exit(1); } else if (vm.count("config-file")) { read_config: conf = Configuration::getInstance(); cout << "Processing config file: " << vm["config-file"].as<string>() << endl; // set up isptap configuration and logging support conf->parseConfigFile(vm["config-file"].as<string>()); if(vm.count("set-arch-file")) { cout << "Manually setting architectual configuration file: " << vm["set-arch-file"].as<string>() << endl; conf->setProperty(CONF_USE_ARCH_CFG_FILE, true); conf->setProperty(CONF_ARCH_CFG_FILE, vm["set-arch-file"].as<string>()); } if(vm.count("set-log-file")) { cout << "Manually setting log output file: " << vm["set-log-file"].as<string>() << endl; conf->setProperty(CONF_LOG_FILE, vm["set-log-file"].as<string>()); } if(vm.count("set-rpt-file")) { cout << "Manually setting report file: " << vm["set-rpt-file"].as<string>() << endl; conf->setProperty(CONF_REPORT_FILE, vm["set-rpt-file"].as<string>()); } if(vm.count("set-log-dir")) { cout << "Manually setting log output dir: " << vm["set-log-dir"].as<string>() << endl; string log_file = conf->getString(CONF_LOG_FILE); log_file = vm["set-log-dir"].as<string>() + log_file; cout << "Log file is now: " << log_file << endl; conf->setProperty(CONF_LOG_FILE, log_file); } if(vm.count("set-rpt-dir")) { cout << "Manually setting report dir: " << vm["set-rpt-dir"].as<string>() << endl; string rpt_file = conf->getString(CONF_REPORT_FILE); rpt_file = vm["set-rpt-dir"].as<string>() + rpt_file; cout << "Report file is now: " << rpt_file << endl; conf->setProperty(CONF_REPORT_FILE, rpt_file); } if(vm.count("set-out-dir")) { if(vm.count("set-log-dir") || vm.count("set-rpt-dir")) { cout << op_desc; exit(1); } cout << "Manually setting output dir: " << vm["set-out-dir"].as<string>() << endl; string out_dir = vm["set-out-dir"].as<string>(); string log_file = conf->getString(CONF_LOG_FILE); log_file = out_dir + log_file; cout << "Log file is now: " << log_file << endl; conf->setProperty(CONF_LOG_FILE, log_file); string rpt_file = conf->getString(CONF_REPORT_FILE); rpt_file =out_dir + rpt_file; cout << "Report file is now: " << rpt_file << endl; conf->setProperty(CONF_REPORT_FILE, rpt_file); } // it could be possible that the log file was changed by an overwrite/set parameter. conf->initializeLogging(); } else { cout << op_desc; exit(1); } isptap_main(conf); cend = clock(); cdiff = (cend-cstart) / 1000000.0; LOG_INFO(logger, "Estimated ISPTAP execution time: " << setprecision(3) << cdiff << " seconds."); return 0; }