int DblMatrix::qtClustering(double thresh, std::vector<DblMatrix>& clusters)
{
/// initialize the members
IntMatrix members;
members.assign(size(), IntVector());
///// each entry is a neighbor of itself
for(unsigned int i=0; i<size(); i++)
members[i].push_back(i);
/// get the other members
for(unsigned int j=0; j<size()-1; j++)
{
for(unsigned int k=j+1; k<size(); k++)
{
double diff = (*this)[j].EuclDist((*this)[k]);
if(diff <= thresh)
{
members[j].push_back(k);
members[k].push_back(j);
}
}
}
/// QT clustering
std::sort(members.begin(), members.end(), IntVectorGreater);
IntMatrix::iterator it1;
int n=0;
for(it1=members.begin(); it1!=members.end(); it1++, n++)
{
for(unsigned int j=1; j<it1->size(); j++)
{
IntMatrix::iterator it2=it1;
it2++;
for(; it2!=members.end();)
{
if((*it1)[j]==it2->front()) it2=members.erase(it2);
else it2++;
}
}
}
/// build groups
clusters.clear();
for(unsigned int i=0; i<members.size(); i++)
{
DblMatrix cluster;
for(unsigned int j=0; j<members[i].size(); j++)
{
cluster.push_back((*this)[members[i][j]]);
}
clusters.push_back(cluster);
}
return 0;
}
void
NIVissimConnection::buildNodeClusters() {
for (DictType::iterator i=myDict.begin(); i!=myDict.end(); i++) {
NIVissimConnection *e = (*i).second;
if (!e->clustered()) {
assert(e->myBoundary!=0&&e->myBoundary->xmax()>e->myBoundary->xmin());
IntVector connections =
NIVissimConnection::getWithin(*(e->myBoundary));
NIVissimNodeCluster::dictionary(-1, -1, connections,
IntVector(), true); // 19.5.!!! should be on a single edge
}
}
}
static bool List2Vector (const string& str, IntVector &v)
{
// parse list
istringstream is(str);
vector<int> lst;
int i;
v.Remove();
while (is >> i) lst.push_back(i);
if (lst.size() > 0) {
v = IntVector(0,lst.size()-1);
for (unsigned k = 0; k < lst.size(); ++k) v(k) = lst[k];
}
return true;
}
/*
*************************************************************************
*
* Get data from input database.
*
*************************************************************************
*/
void
CVODEModel::getFromInput(
std::shared_ptr<Database> input_db,
bool is_from_restart)
{
NULL_USE(is_from_restart);
d_initial_value = input_db->getDoubleWithDefault("initial_value", 0.0);
IntVector periodic(d_grid_geometry->getPeriodicShift(IntVector(d_dim,
1)));
int num_per_dirs = 0;
for (int id = 0; id < d_dim.getValue(); ++id) {
if (periodic(id)) ++num_per_dirs;
}
if (input_db->keyExists("Boundary_data")) {
std::shared_ptr<Database> boundary_db(
input_db->getDatabase("Boundary_data"));
if (d_dim == Dimension(2)) {
CartesianBoundaryUtilities2::getFromInput(this,
boundary_db,
d_scalar_bdry_edge_conds,
d_scalar_bdry_node_conds,
periodic);
} else if (d_dim == Dimension(3)) {
CartesianBoundaryUtilities3::getFromInput(this,
boundary_db,
d_scalar_bdry_face_conds,
d_scalar_bdry_edge_conds,
d_scalar_bdry_node_conds,
periodic);
}
} else {
TBOX_WARNING(
d_object_name << ": "
<< "Key data `Boundary_data' not found in input. " << endl);
}
#ifdef USE_FAC_PRECONDITIONER
d_use_neumann_bcs =
input_db->getBoolWithDefault("use_neumann_bcs", d_use_neumann_bcs);
d_print_solver_info =
input_db->getBoolWithDefault("print_solver_info", d_print_solver_info);
#endif
}
IntVector tokenize(const std::string& str, char delim, char group) {
IntVector tokens;
if(str.empty()) {
return tokens;
}
int curr = 0;
int start = 0;
start = curr = static_cast<int>(str.find_first_not_of(delim));
while(str[curr]) {
if(str[curr] == group) {
curr = static_cast<int>(str.find_first_of(group, curr+1));
if((size_t)curr == std::string::npos) {
return IntVector();
}
std::string token = str.substr(start+1, curr-start-1);
tokens.push_back(makeInt32(token));
start = curr + 1;
} else if(str[curr] == delim) {
if(str[curr-1] != delim && str[curr-1] != group) {
std::string token = str.substr(start, curr-start);
tokens.push_back(makeInt32(token));
}
start = curr + 1;
}
++curr;
}
if(tokens.size() == 0) {
tokens.push_back(makeInt32(str));
return tokens;
}
if(str[curr-1] != delim && str[curr-1] != group) {
std::string token = str.substr(start, curr - 1);
tokens.push_back(makeInt32(token));
}
return tokens;
}
unsigned long IntMatrix::Load(std::string Name, bool Append)
{
if(!Append) this->clear();
std::ifstream f(Name.c_str(), std::fstream::in);
if(!f.is_open()){std::cout << "Could not load: " << Name << "\n"; return RET_FAILED;}
int Size;
f >> Size;
for(int j=0; j<Size; j++)
{
int Size2;
f >> Size2;
this->push_back(IntVector());
for(int i=0; i<Size2; i++)
{
int val;
f >> val;
(*this)[j].push_back(val);
}
}
return RET_OK;
}
// ===========================================================================
// method definitions
// ===========================================================================
void
MSFrame::fillOptions() {
OptionsCont& oc = OptionsCont::getOptions();
oc.addCallExample("-b 0 -e 1000 -n net.xml -r routes.xml", "start a simulation from time 0 to 1000 with given net and routes");
oc.addCallExample("-c munich_config.cfg", "start with a configuration file");
oc.addCallExample("--help", "print help");
// insert options sub-topics
SystemFrame::addConfigurationOptions(oc); // fill this subtopic, too
oc.addOptionSubTopic("Input");
oc.addOptionSubTopic("Output");
oc.addOptionSubTopic("Time");
oc.addOptionSubTopic("Processing");
SystemFrame::addReportOptions(oc); // fill this subtopic, too
// register configuration options
// register input options
oc.doRegister("net-file", 'n', new Option_FileName());
oc.addSynonyme("net-file", "net");
oc.addDescription("net-file", "Input", "Load road network description from FILE");
oc.doRegister("route-files", 'r', new Option_FileName());
oc.addSynonyme("route-files", "routes");
oc.addDescription("route-files", "Input", "Load routes descriptions from FILE(s)");
oc.doRegister("additional-files", 'a', new Option_FileName());
oc.addSynonyme("additional-files", "additional");
oc.addDescription("additional-files", "Input", "Load further descriptions from FILE(s)");
oc.doRegister("weight-files", 'w', new Option_FileName());
oc.addSynonyme("weight-files", "weights");
oc.addDescription("weight-files", "Input", "Load edge/lane weights for online rerouting from FILE");
oc.doRegister("weight-attribute", 'x', new Option_String("traveltime"));
oc.addSynonyme("weight-attribute", "measure", true);
oc.addDescription("weight-attribute", "Input", "Name of the xml attribute which gives the edge weight");
#ifdef HAVE_INTERNAL
oc.doRegister("load-state", new Option_FileName());//!!! check, describe
oc.addDescription("load-state", "Input", "Loads a network state from FILE");
oc.doRegister("load-state.offset", new Option_String("0", "TIME"));//!!! check, describe
oc.addDescription("load-state.offset", "Input", "Sets the time offset for vehicle segment exit times.");
#endif
// register output options
oc.doRegister("netstate-dump", new Option_FileName());
oc.addSynonyme("netstate-dump", "ndump");
oc.addSynonyme("netstate-dump", "netstate");
oc.addDescription("netstate-dump", "Output", "Save complete network states into FILE");
oc.doRegister("netstate-dump.empty-edges", new Option_Bool(false));
oc.addSynonyme("netstate-dump.empty-edges", "netstate.empty-edges");
oc.addSynonyme("netstate-dump.empty-edges", "dump-empty-edges", true);
oc.addDescription("netstate-dump.empty-edges", "Output", "Write also empty edges completely when dumping");
oc.doRegister("emission-output", new Option_FileName());
oc.addDescription("emission-output", "Output", "Save the emission values of each vehicle");
oc.doRegister("fcd-output", new Option_FileName());
oc.addDescription("fcd-output", "Output", "Save the Floating Car Data");
oc.doRegister("fcd-output.geo", new Option_Bool(false));
oc.addDescription("fcd-output.geo", "Output", "Save the Floating Car Data using geo-coordinates (lon/lat)");
oc.doRegister("full-output", new Option_FileName());
oc.addDescription("full-output", "Output", "Save a lot of information for each timestep (very redundant)");
oc.doRegister("queue-output", new Option_FileName());
oc.addDescription("queue-output", "Output", "Save the vehicle queues at the junctions (experimental)");
oc.doRegister("vtk-output", new Option_FileName());
oc.addDescription("vtk-output", "Output", "Save complete vehicle positions in VTK Format (usage: /file/out will produce /file/out_$NR$.vtp files)");
oc.doRegister("summary-output", new Option_FileName());
oc.addSynonyme("summary-output", "summary");
oc.addSynonyme("summary-output", "emissions-output", true);
oc.addSynonyme("summary-output", "emissions", true);
oc.addDescription("summary-output", "Output", "Save aggregated vehicle departure info into FILE");
oc.doRegister("tripinfo-output", new Option_FileName());
oc.addSynonyme("tripinfo-output", "tripinfo");
oc.addDescription("tripinfo-output", "Output", "Save single vehicle trip info into FILE");
oc.doRegister("vehroute-output", new Option_FileName());
oc.addSynonyme("vehroute-output", "vehroutes");
oc.addDescription("vehroute-output", "Output", "Save single vehicle route info into FILE");
oc.doRegister("vehroute-output.exit-times", new Option_Bool(false));
oc.addSynonyme("vehroute-output.exit-times", "vehroutes.exit-times");
oc.addDescription("vehroute-output.exit-times", "Output", "Write the exit times for all edges");
oc.doRegister("vehroute-output.last-route", new Option_Bool(false));
oc.addSynonyme("vehroute-output.last-route", "vehroutes.last-route");
oc.addDescription("vehroute-output.last-route", "Output", "Write the last route only");
oc.doRegister("vehroute-output.sorted", new Option_Bool(false));
oc.addSynonyme("vehroute-output.sorted", "vehroutes.sorted");
oc.addDescription("vehroute-output.sorted", "Output", "Sorts the output by departure time");
oc.doRegister("vehroute-output.write-unfinished", new Option_Bool(false));
oc.addDescription("vehroute-output.write-unfinished", "Output", "Write vehroute output for vehicles which have not arrived at simulation end");
#ifdef HAVE_INTERNAL
oc.doRegister("save-state.times", new Option_IntVector(IntVector()));//!!! check, describe
oc.addDescription("save-state.times", "Output", "Use INT[] as times at which a network state written");
oc.doRegister("save-state.prefix", new Option_FileName("state"));//!!! check, describe
oc.addDescription("save-state.prefix", "Output", "Prefix for network states");
oc.doRegister("save-state.files", new Option_FileName());//!!! check, describe
oc.addDescription("save-state.files", "Output", "Files for network states");
#endif
// register the simulation settings
oc.doRegister("begin", 'b', new Option_String("0", "TIME"));
oc.addDescription("begin", "Time", "Defines the begin time; The simulation starts at this time");
oc.doRegister("end", 'e', new Option_String("-1", "TIME"));
oc.addDescription("end", "Time", "Defines the end time; The simulation ends at this time");
#ifdef HAVE_SUBSECOND_TIMESTEPS
oc.doRegister("step-length", new Option_String("1", "TIME"));
oc.addDescription("step-length", "Time", "Defines the step duration");
#endif
// register the processing options
oc.doRegister("route-steps", 's', new Option_String("200", "TIME"));
oc.addDescription("route-steps", "Processing", "Load routes for the next number of seconds ahead");
#ifdef HAVE_INTERNAL_LANES
oc.doRegister("no-internal-links", new Option_Bool(false));
oc.addDescription("no-internal-links", "Processing", "Disable (junction) internal links");
#endif
oc.doRegister("ignore-accidents", new Option_Bool(false));
oc.addDescription("ignore-accidents", "Processing", "Do not check whether accidents occure more deeply");
oc.doRegister("ignore-route-errors", new Option_Bool(false));
oc.addDescription("ignore-route-errors", "Processing", "Do not check whether routes are connected");
oc.doRegister("max-num-vehicles", new Option_Integer(-1));
oc.addSynonyme("max-num-vehicles", "too-many-vehicles", true);
oc.addDescription("max-num-vehicles", "Processing", "Quit simulation if this number of vehicles is exceeded");
oc.doRegister("incremental-dua-step", new Option_Integer());//!!! deprecated
oc.addDescription("incremental-dua-step", "Processing", "Perform the simulation as a step in incremental DUA");
oc.doRegister("incremental-dua-base", new Option_Integer(10));//!!! deprecated
oc.addDescription("incremental-dua-base", "Processing", "Base value for incremental DUA");
oc.doRegister("scale", new Option_Float());
oc.addDescription("scale", "Processing", "Scale demand by the given factor (0..1)");
oc.doRegister("time-to-teleport", new Option_String("300", "TIME"));
oc.addDescription("time-to-teleport", "Processing", "Specify how long a vehicle may wait until being teleported, defaults to 300, non-positive values disable teleporting");
oc.doRegister("max-depart-delay", new Option_String("-1", "TIME"));
oc.addDescription("max-depart-delay", "Processing", "How long vehicles wait for departure before being skipped, defaults to -1 which means vehicles are never skipped");
oc.doRegister("sloppy-insert", new Option_Bool(false));
oc.addDescription("sloppy-insert", "Processing", "Whether insertion on an edge shall not be repeated in same step once failed.");
oc.doRegister("lanechange.allow-swap", new Option_Bool(false));
oc.addDescription("lanechange.allow-swap", "Processing", "Whether blocking vehicles trying to change lanes may be swapped.");
oc.doRegister("routing-algorithm", new Option_String("dijkstra"));
oc.addDescription("routing-algorithm", "Processing",
"Select among routing algorithms ['dijkstra', 'astar']");
oc.doRegister("routeDist.maxsize", new Option_Integer());
oc.addDescription("routeDist.maxsize", "Processing",
"Restrict the maximum size of route distributions");
// devices
MSDevice_Routing::insertOptions();
MSDevice_HBEFA::insertOptions();
// register report options
oc.doRegister("no-duration-log", new Option_Bool(false));
oc.addDescription("no-duration-log", "Report", "Disable performance reports for individual simulation steps");
oc.doRegister("no-step-log", new Option_Bool(false));
oc.addDescription("no-step-log", "Report", "Disable console output of current simulation step");
#ifndef NO_TRACI
//remote port 0 if not used
oc.addOptionSubTopic("TraCI Server");
oc.doRegister("remote-port", new Option_Integer(0));
oc.addDescription("remote-port", "TraCI Server", "Enables TraCI Server if set");
#ifdef HAVE_PYTHON
oc.doRegister("python-script", new Option_String());
oc.addDescription("python-script", "TraCI Server", "Runs TraCI script with embedded python");
#endif
#endif
//
#ifdef HAVE_INTERNAL
oc.addOptionSubTopic("Mesoscopic");
oc.doRegister("mesosim", new Option_Bool(false));
oc.addDescription("mesosim", "Mesoscopic", "Enables mesoscopic simulation");
oc.doRegister("meso-edgelength", new Option_Float(98.0f));
oc.addDescription("meso-edgelength", "Mesoscopic", "Length of an edge segment in mesoscopic simulation");
oc.doRegister("meso-tauff", new Option_String("1.4", "TIME"));
oc.addDescription("meso-tauff", "Mesoscopic", "Factor for calculating the free-free headway time");
oc.doRegister("meso-taufj", new Option_String("1.4", "TIME"));
oc.addDescription("meso-taufj", "Mesoscopic", "Factor for calculating the free-jam headway time");
oc.doRegister("meso-taujf", new Option_String("2", "TIME"));
oc.addDescription("meso-taujf", "Mesoscopic", "Factor for calculating the jam-free headway time");
oc.doRegister("meso-taujj", new Option_String("2", "TIME"));
oc.addDescription("meso-taujj", "Mesoscopic", "Factor for calculating the jam-jam headway time");
oc.doRegister("meso-jam-threshold", new Option_Float(-1));
oc.addDescription("meso-jam-threshold", "Mesoscopic", "Minimum percentage of occupied space to consider a segment jammed. A negative argument causes thresholds to be computed based on edge speed and tauff (default)");
oc.doRegister("meso-multi-queue", new Option_Bool(false));
oc.addDescription("meso-multi-queue", "Mesoscopic", "Enable multiple queues at edge ends");
oc.doRegister("meso-junction-control", new Option_Bool(false));
oc.addDescription("meso-junction-control", "Mesoscopic", "Enable mesoscopic traffic light and priority junction handling");
oc.doRegister("meso-junction-control.limited", new Option_Bool(false));
oc.addDescription("meso-junction-control.limited", "Mesoscopic", "Enable mesoscopic traffic light and priority junction handling for saturated links. This prevents faulty traffic lights from hindering flow in low-traffic situations");
oc.doRegister("meso-recheck", new Option_String("0", "TIME"));
oc.addDescription("meso-recheck", "Mesoscopic", "Time interval for rechecking insertion into the next segment after failure");
#endif
// add rand options
RandHelper::insertRandOptions();
// add GUI options
// the reason that we include them in vanilla sumo as well is to make reusing config files easy
oc.addOptionSubTopic("GUI Only");
oc.doRegister("gui-settings-file", new Option_FileName());
oc.addDescription("gui-settings-file", "GUI Only", "Load visualisation settings from FILE");
oc.doRegister("quit-on-end", 'Q', new Option_Bool(false));
oc.addDescription("quit-on-end", "GUI Only", "Quits the GUI when the simulation stops");
oc.doRegister("game", 'G', new Option_Bool(false));
oc.addDescription("game", "GUI Only", "Start the GUI in gaming mode");
oc.doRegister("start", 'S', new Option_Bool(false));
oc.addDescription("start", "GUI Only", "Start the simulation after loading");
oc.doRegister("disable-textures", 'T', new Option_Bool(false));
oc.addDescription("disable-textures", "GUI Only", "Do not load background pictures");
}
bool PixelMap::isCollision(const RectMap &rectmap, const IntPoint &pos1, const IntPoint &pos2, const IntRect &rect1, const IntRect &rect2, const Alignment &alignment1, const Alignment &alignment2) const
{
IntPoint corner1(pos1), corner2(pos2);
IntRect framerect1, framerect2;
IntRect mrect1, mrect2;
IntRect *cutrect;
/* Break */
if(map == NULL)
return false;
/* Translate negative axises */
mrect1 = rect_translate_negative_axises(rect1, size);
mrect2 = rect_translate_negative_axises(rect2, rectmap.getSize());
/* Align */
if(alignment1.getX() != 0) corner1.decX((int)(mrect1.getWidth() * alignment1.getX()));
if(alignment1.getY() != 0) corner1.decY((int)(mrect1.getHeight() * alignment1.getY()));
if(alignment2.getX() != 0) corner2.decX((int)(mrect2.getWidth() * alignment2.getX()));
if(alignment2.getY() != 0) corner2.decY((int)(mrect2.getHeight() * alignment2.getY()));
/* Framerects */
framerect1.load(corner1.getX(), corner1.getY(), mrect1.getWidth(), mrect1.getHeight());
framerect2.load(corner2.getX(), corner2.getY(), mrect2.getWidth(), mrect2.getHeight());
/* Break */
if(!size_to_rect(size).isCovering(mrect1))
throw Exception() << "pixelmap1 doesn't fully cover rect";
/* Cutrect */
if((cutrect = framerect1.getCutrect(framerect2)) == NULL)
return false;
/* Iterate rects, check pixels */
for(int r = 0; r < rectmap.getRectCount(); r++)
{
int fpx, fpy; /* First pixel to check */
int lpx, lpy; /* Last pixel to check */
IntRect srect = rectmap.getRect(r) + point_to_vector(corner2) - IntVector(mrect2.getX(), mrect2.getY());
IntRect *scutrect;
/* Clip with cutrect*/
if((scutrect = srect.getCutrect(*cutrect)) == NULL)
continue;
/* Pixels to check */
fpx = scutrect->getX() - (corner1.getX() - mrect1.getX());
fpy = scutrect->getY() - (corner1.getY() - mrect1.getY());
lpx = fpx + scutrect->getWidth() - 1;
lpy = fpy + scutrect->getHeight() - 1;
/* Check pixels */
for(int py = fpy; py <= lpy; py++)
{
for(int px = fpx; px <= lpx; px++)
{
if(is_pixel(px, py))
{
/* Free mem */
delete cutrect;
delete scutrect;
/* Collision detected */
return true;
}
}
}
delete scutrect;
}
delete cutrect;
return false;
}
void MixedVariables::build_inactive_views()
{
// Initialize continuousVarTypes/discreteVarTypes/continuousVarIds.
// Don't bleed over any logic about supported view combinations; rather,
// keep this class general and encapsulated.
const SizetArray& vc_totals = sharedVarsData.components_totals();
size_t num_cdv = vc_totals[0], num_ddiv = vc_totals[1],
num_ddrv = vc_totals[2], num_cauv = vc_totals[3], num_dauiv = vc_totals[4],
num_daurv = vc_totals[5], num_ceuv = vc_totals[6], num_deuiv = vc_totals[7],
num_deurv = vc_totals[8], num_csv = vc_totals[9], num_dsiv = vc_totals[10],
num_dsrv = vc_totals[11];
// Initialize inactive views
size_t icv_start, idiv_start, idrv_start, num_icv, num_idiv, num_idrv;
switch (sharedVarsData.view().second) {
case EMPTY:
icv_start = idiv_start = idrv_start = num_icv = num_idiv = num_idrv = 0;
break;
case MIXED_ALL:
Cerr << "Error: inactive view cannot be MIXED_ALL in MixedVariables."
<< std::endl;
abort_handler(-1); break;
case MIXED_DESIGN:
// start at the beginning
icv_start = idiv_start = idrv_start = 0;
num_icv = num_cdv;
num_idiv = num_ddiv;
num_idrv = num_ddrv; break;
case MIXED_ALEATORY_UNCERTAIN:
// skip over the design variables
icv_start = num_cdv; num_icv = num_cauv;
idiv_start = num_ddiv; num_idiv = num_dauiv;
idrv_start = num_ddrv; num_idrv = num_daurv; break;
case MIXED_EPISTEMIC_UNCERTAIN:
// skip over the design and aleatory uncertain variables
icv_start = num_cdv + num_cauv; num_icv = num_ceuv;
idiv_start = num_ddiv + num_dauiv; num_idiv = num_deuiv;
idrv_start = num_ddrv + num_daurv; num_idrv = num_deurv; break;
case MIXED_UNCERTAIN:
// skip over the design variables
icv_start = num_cdv; num_icv = num_cauv + num_ceuv;
idiv_start = num_ddiv; num_idiv = num_dauiv + num_deuiv;
idrv_start = num_ddrv; num_idrv = num_daurv + num_deurv; break;
case MIXED_STATE:
// skip over all the design and uncertain variables
icv_start = num_cdv + num_cauv + num_ceuv; num_icv = num_csv;
idiv_start = num_ddiv + num_dauiv + num_deuiv; num_idiv = num_dsiv;
idrv_start = num_ddrv + num_daurv + num_deurv; num_idrv = num_dsrv; break;
}
sharedVarsData.icv_start(icv_start); sharedVarsData.icv(num_icv);
sharedVarsData.idiv_start(idiv_start); sharedVarsData.idiv(num_idiv);
sharedVarsData.idrv_start(idrv_start); sharedVarsData.idrv(num_idrv);
sharedVarsData.initialize_inactive_components();
if (num_icv)
inactiveContinuousVars
= RealVector(Teuchos::View, &allContinuousVars[icv_start], num_icv);
if (num_idiv)
inactiveDiscreteIntVars
= IntVector(Teuchos::View, &allDiscreteIntVars[idiv_start], num_idiv);
if (num_idrv)
inactiveDiscreteRealVars
= RealVector(Teuchos::View, &allDiscreteRealVars[idrv_start], num_idrv);
}
CVODEModel::CVODEModel(
const string& object_name,
const Dimension& dim,
std::shared_ptr<CellPoissonFACSolver> fac_solver,
std::shared_ptr<Database> input_db,
std::shared_ptr<CartesianGridGeometry> grid_geom):
RefinePatchStrategy(),
CoarsenPatchStrategy(),
d_object_name(object_name),
d_dim(dim),
d_soln_var(new CellVariable<double>(dim, "soln", 1)),
d_FAC_solver(fac_solver),
d_grid_geometry(grid_geom)
{
/*
* set up variables and contexts
*/
VariableDatabase* variable_db = VariableDatabase::getDatabase();
d_cur_cxt = variable_db->getContext("CURRENT");
d_scr_cxt = variable_db->getContext("SCRATCH");
d_soln_cur_id = variable_db->registerVariableAndContext(d_soln_var,
d_cur_cxt,
IntVector(d_dim, 0));
d_soln_scr_id = variable_db->registerVariableAndContext(d_soln_var,
d_scr_cxt,
IntVector(d_dim, 1));
#ifdef USE_FAC_PRECONDITIONER
d_diff_var.reset(new SideVariable<double>(d_dim, "diffusion",
hier::IntVector::getOne(d_dim), 1));
d_diff_id = variable_db->registerVariableAndContext(d_diff_var,
d_cur_cxt,
IntVector(d_dim, 0));
/*
* Set default values for preconditioner.
*/
d_use_neumann_bcs = false;
d_current_soln_time = 0.;
#endif
/*
* Print solver data.
*/
d_print_solver_info = false;
/*
* Counters.
*/
d_number_rhs_eval = 0;
d_number_precond_setup = 0;
d_number_precond_solve = 0;
/*
* Boundary condition initialization.
*/
if (d_dim == Dimension(2)) {
d_scalar_bdry_edge_conds.resize(NUM_2D_EDGES);
for (int ei = 0; ei < NUM_2D_EDGES; ++ei) {
d_scalar_bdry_edge_conds[ei] = BOGUS_BDRY_DATA;
}
d_scalar_bdry_node_conds.resize(NUM_2D_NODES);
d_node_bdry_edge.resize(NUM_2D_NODES);
for (int ni = 0; ni < NUM_2D_NODES; ++ni) {
d_scalar_bdry_node_conds[ni] = BOGUS_BDRY_DATA;
d_node_bdry_edge[ni] = BOGUS_BDRY_DATA;
}
d_bdry_edge_val.resize(NUM_2D_EDGES);
MathUtilities<double>::setVectorToSignalingNaN(d_bdry_edge_val);
} else if (d_dim == Dimension(3)) {
d_scalar_bdry_face_conds.resize(NUM_3D_FACES);
for (int fi = 0; fi < NUM_3D_FACES; ++fi) {
d_scalar_bdry_face_conds[fi] = BOGUS_BDRY_DATA;
}
d_scalar_bdry_edge_conds.resize(NUM_3D_EDGES);
d_edge_bdry_face.resize(NUM_3D_EDGES);
for (int ei = 0; ei < NUM_3D_EDGES; ++ei) {
d_scalar_bdry_edge_conds[ei] = BOGUS_BDRY_DATA;
d_edge_bdry_face[ei] = BOGUS_BDRY_DATA;
}
d_scalar_bdry_node_conds.resize(NUM_3D_NODES);
d_node_bdry_face.resize(NUM_3D_NODES);
for (int ni = 0; ni < NUM_3D_NODES; ++ni) {
d_scalar_bdry_node_conds[ni] = BOGUS_BDRY_DATA;
d_node_bdry_face[ni] = BOGUS_BDRY_DATA;
}
d_bdry_face_val.resize(NUM_3D_FACES);
MathUtilities<double>::setVectorToSignalingNaN(d_bdry_face_val);
}
/*
* Initialize object with data read from given input/restart databases.
*/
bool is_from_restart = RestartManager::getManager()->isFromRestart();
if (is_from_restart) {
getFromRestart();
}
getFromInput(input_db, is_from_restart);
#ifdef USE_FAC_PRECONDITIONER
/*
* Construct outerface variable to hold boundary flags and Neumann fluxes.
*/
if (d_use_neumann_bcs) {
d_flag_var.reset(new OuterfaceVariable<int>(d_dim, "bdryflag", 1));
d_flag_id = variable_db->registerVariableAndContext(d_flag_var,
d_cur_cxt,
IntVector(d_dim, 0));
d_neuf_var.reset(new OuterfaceVariable<double>(d_dim, "neuflux", 1));
d_neuf_id = variable_db->registerVariableAndContext(d_neuf_var,
d_cur_cxt,
IntVector(d_dim, 0));
} else {
d_flag_id = -1;
d_neuf_id = -1;
}
/*
* Set boundary types for FAC preconditioner.
* bdry_types holds a flag where 0 = dirichlet, 1 = neumann
*/
if (d_dim == Dimension(2)) {
for (int i = 0; i < NUM_2D_EDGES; ++i) {
d_bdry_types[i] = 0;
if (d_scalar_bdry_edge_conds[i] == BdryCond::DIRICHLET) d_bdry_types[i] = 0;
if (d_scalar_bdry_edge_conds[i] == BdryCond::NEUMANN) d_bdry_types[i] = 1;
}
} else if (d_dim == Dimension(3)) {
for (int i = 0; i < NUM_3D_FACES; ++i) {
d_bdry_types[i] = 0;
if (d_scalar_bdry_face_conds[i] == BdryCond::DIRICHLET) d_bdry_types[i] = 0;
if (d_scalar_bdry_face_conds[i] == BdryCond::NEUMANN) d_bdry_types[i] = 1;
}
}
#endif
/*
* Postprocess boundary data from input/restart values. Note: scalar
* quantity in this problem cannot have reflective boundary conditions
* so we reset them to BdryCond::FLOW.
*/
if (d_dim == Dimension(2)) {
for (int i = 0; i < NUM_2D_EDGES; ++i) {
if (d_scalar_bdry_edge_conds[i] == BdryCond::REFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::FLOW;
}
}
for (int i = 0; i < NUM_2D_NODES; ++i) {
if (d_scalar_bdry_node_conds[i] == BdryCond::XREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::XFLOW;
}
if (d_scalar_bdry_node_conds[i] == BdryCond::YREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::YFLOW;
}
if (d_scalar_bdry_node_conds[i] != BOGUS_BDRY_DATA) {
d_node_bdry_edge[i] =
CartesianBoundaryUtilities2::getEdgeLocationForNodeBdry(
i, d_scalar_bdry_node_conds[i]);
}
}
} else if (d_dim == Dimension(3)) {
for (int i = 0; i < NUM_3D_FACES; ++i) {
if (d_scalar_bdry_face_conds[i] == BdryCond::REFLECT) {
d_scalar_bdry_face_conds[i] = BdryCond::FLOW;
}
}
for (int i = 0; i < NUM_3D_EDGES; ++i) {
if (d_scalar_bdry_edge_conds[i] == BdryCond::XREFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::XFLOW;
}
if (d_scalar_bdry_edge_conds[i] == BdryCond::YREFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::YFLOW;
}
if (d_scalar_bdry_edge_conds[i] == BdryCond::ZREFLECT) {
d_scalar_bdry_edge_conds[i] = BdryCond::ZFLOW;
}
if (d_scalar_bdry_edge_conds[i] != BOGUS_BDRY_DATA) {
d_edge_bdry_face[i] =
CartesianBoundaryUtilities3::getFaceLocationForEdgeBdry(
i, d_scalar_bdry_edge_conds[i]);
}
}
for (int i = 0; i < NUM_3D_NODES; ++i) {
if (d_scalar_bdry_node_conds[i] == BdryCond::XREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::XFLOW;
}
if (d_scalar_bdry_node_conds[i] == BdryCond::YREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::YFLOW;
}
if (d_scalar_bdry_node_conds[i] == BdryCond::ZREFLECT) {
d_scalar_bdry_node_conds[i] = BdryCond::ZFLOW;
}
if (d_scalar_bdry_node_conds[i] != BOGUS_BDRY_DATA) {
d_node_bdry_face[i] =
CartesianBoundaryUtilities3::getFaceLocationForNodeBdry(
i, d_scalar_bdry_node_conds[i]);
}
}
}
}
void FileFlattener::appendFolder()
{
folders.push_back(IntVector());
}
// ===========================================================================
// method definitions
// ===========================================================================
void
MSFrame::fillOptions() {
OptionsCont& oc = OptionsCont::getOptions();
oc.addCallExample("-b 0 -e 1000 -n net.xml -r routes.xml");
oc.addCallExample("-c munich_config.cfg");
oc.addCallExample("--help");
// insert options sub-topics
SystemFrame::addConfigurationOptions(oc); // fill this subtopic, too
oc.addOptionSubTopic("Input");
oc.addOptionSubTopic("Output");
oc.addOptionSubTopic("Time");
oc.addOptionSubTopic("Processing");
SystemFrame::addReportOptions(oc); // fill this subtopic, too
// register configuration options
// register input options
oc.doRegister("net-file", 'n', new Option_FileName());
oc.addSynonyme("net-file", "net");
oc.addDescription("net-file", "Input", "Load road network description from FILE");
oc.doRegister("route-files", 'r', new Option_FileName());
oc.addSynonyme("route-files", "routes");
oc.addDescription("route-files", "Input", "Load routes descriptions from FILE(s)");
oc.doRegister("additional-files", 'a', new Option_FileName());
oc.addSynonyme("additional-files", "additional");
oc.addDescription("additional-files", "Input", "Load additional descriptions from FILE(s)");
/* *
* The 'extraInf' option is being added by the HI-Iberia (doancea).
* This option shall be registered in order to be able to load additional configuration files.*/
oc.doRegister("extra-file", 'E', new Option_FileName());
oc.addSynonyme("extra-file", "external description file");
oc.addDescription("extra-file", "Input", "Load scenario simulation description from FILE(s)");
// Here ends HI-Iberia contribution.
oc.doRegister("weight-files", 'w', new Option_FileName());
oc.addSynonyme("weight-files", "weights");
oc.addDescription("weight-files", "Input", "Load edge/lane weights for online rerouting from FILE");
oc.doRegister("weight-attribute", 'x', new Option_String("traveltime"));
oc.addSynonyme("weight-attribute", "measure", true);
oc.addDescription("weight-attribute", "Input", "Name of the xml attribute which gives the edge weight");
#ifdef HAVE_MESOSIM
oc.doRegister("load-state", new Option_FileName());//!!! check, describe
oc.addDescription("load-state", "Input", "Loads a network state from FILE");
oc.doRegister("load-state.offset", new Option_String("0", "TIME"));//!!! check, describe
oc.addDescription("load-state.offset", "Input", "Sets the time offset for vehicle segment exit times.");
#endif
// register output options
oc.doRegister("netstate-dump-fev", new Option_FileName());
oc.doRegister("netstate-dump", new Option_FileName());
oc.addSynonyme("netstate-dump", "ndump");
oc.addSynonyme("netstate-dump", "netstate");
oc.addSynonyme("netstate-dump-fev", "the simulation result file"); // Added by HI-Iberia (doancea)
oc.addDescription("netstate-dump", "Output", "Save complete network states into FILE");
oc.addDescription("netstate-dump-fev","Output","Save electric vehicle simulation states into a FILE"); //Added by HI-Iberia (doancea)
oc.doRegister("netstate-dump.empty-edges", new Option_Bool(false));
oc.addSynonyme("netstate-dump.empty-edges", "netstate.empty-edges");
oc.addSynonyme("netstate-dump.empty-edges", "dump-empty-edges", true);
oc.addDescription("netstate-dump.empty-edges", "Output", "Write also empty edges completely when dumping");
oc.doRegister("summary-output", new Option_FileName());
oc.addSynonyme("summary-output", "summary");
oc.addSynonyme("summary-output", "emissions-output", true);
oc.addSynonyme("summary-output", "emissions", true);
oc.addDescription("summary-output", "Output", "Save aggregated vehicle departure info into FILE");
oc.doRegister("tripinfo-output", new Option_FileName());
oc.addSynonyme("tripinfo-output", "tripinfo");
oc.addDescription("tripinfo-output", "Output", "Save single vehicle trip info into FILE");
oc.doRegister("tripinfo-fev", new Option_FileName());
oc.addSynonyme("tripinfo-fev", "tripinfofev");
oc.addDescription("tripinfo-fev", "Output", "Save single vehicle trip info into FILE");
oc.doRegister("vehroute-output", new Option_FileName());
oc.addSynonyme("vehroute-output", "vehroutes");
oc.addDescription("vehroute-output", "Output", "Save single vehicle route info into FILE");
oc.doRegister("vehroute-output.exit-times", new Option_Bool(false));
oc.addSynonyme("vehroute-output.exit-times", "vehroutes.exit-times");
oc.addDescription("vehroute-output.exit-times", "Output", "Write the exit times for all edges");
oc.doRegister("vehroute-output.last-route", new Option_Bool(false));
oc.addSynonyme("vehroute-output.last-route", "vehroutes.last-route");
oc.addDescription("vehroute-output.last-route", "Output", "Write the last route only");
oc.doRegister("vehroute-output.sorted", new Option_Bool(false));
oc.addSynonyme("vehroute-output.sorted", "vehroutes.sorted");
oc.addDescription("vehroute-output.sorted", "Output", "Sorts the output by departure time");
#ifdef HAVE_MESOSIM
oc.doRegister("save-state.times", new Option_IntVector(IntVector()));//!!! check, describe
oc.addDescription("save-state.times", "Output", "Use INT[] as times at which a network state written");
oc.doRegister("save-state.prefix", new Option_FileName());//!!! check, describe
oc.addDescription("save-state.prefix", "Output", "Prefix for network states");
oc.doRegister("save-state.files", new Option_FileName());//!!! check, describe
oc.addDescription("save-state.files", "Output", "Files for network states");
#endif
// register the simulation settings
oc.doRegister("begin", 'b', new Option_String("0", "TIME"));
oc.addDescription("begin", "Time", "Defines the begin time; The simulation starts at this time");
oc.doRegister("end", 'e', new Option_String("-1", "TIME"));
oc.addDescription("end", "Time", "Defines the end time; The simulation ends at this time");
#ifdef HAVE_SUBSECOND_TIMESTEPS
oc.doRegister("step-length", new Option_String("1", "TIME"));
oc.addDescription("step-length", "Time", "Defines the step duration");
#endif
// register the processing options
oc.doRegister("route-steps", 's', new Option_Integer(200));
oc.addDescription("route-steps", "Processing", "Load routes for the next INT seconds ahead");
#ifdef HAVE_INTERNAL_LANES
oc.doRegister("no-internal-links", new Option_Bool(false));
oc.addDescription("no-internal-links", "Processing", "Disable (junction) internal links");
#endif
oc.doRegister("ignore-accidents", new Option_Bool(false));
oc.addDescription("ignore-accidents", "Processing", "Do not check whether accidents occure more deeply");
oc.doRegister("ignore-route-errors", new Option_Bool(false));
oc.addDescription("ignore-route-errors", "Processing", "Do not check whether routes are connected");
oc.doRegister("max-num-vehicles", new Option_Integer(-1));
oc.addSynonyme("max-num-vehicles", "too-many-vehicles", true);
oc.addDescription("max-num-vehicles", "Processing", "Quit simulation if this number of vehicles is exceeded");
oc.doRegister("incremental-dua-step", new Option_Integer());//!!! deprecated
oc.addDescription("incremental-dua-step", "Processing", "Perform the simulation as a step in incremental DUA");
oc.doRegister("incremental-dua-base", new Option_Integer(10));//!!! deprecated
oc.addDescription("incremental-dua-base", "Processing", "Base value for incremental DUA");
oc.doRegister("scale", new Option_Float());
oc.addDescription("scale", "Processing", "Scale demand by the given factor (0..1)");
oc.doRegister("time-to-teleport", new Option_String("300", "TIME"));
oc.addDescription("time-to-teleport", "Processing", "Specify how long a vehicle may wait until being teleported, defaults to 300, non-positive values disable teleporting");
oc.doRegister("max-depart-delay", new Option_String("-1", "TIME"));
oc.addDescription("max-depart-delay", "Processing", "How long vehicles wait for departure before being skipped, defaults to -1 which means vehicles are never skipped");
oc.doRegister("sloppy-insert", new Option_Bool(false));
oc.addDescription("sloppy-insert", "Processing", "Whether insertion on an edge shall not be repeated in same step once failed.");
oc.doRegister("lanechange.allow-swap", new Option_Bool(false));
oc.addDescription("lanechange.allow-swap", "Processing", "Whether blocking vehicles trying to change lanes may be swapped.");
// devices
MSDevice_Routing::insertOptions();
MSDevice_HBEFA::insertOptions();
//MSDevice_FEV::insertOptions();
// register report options
oc.doRegister("no-duration-log", new Option_Bool(false));
oc.addDescription("no-duration-log", "Report", "Disable performance reports for individual simulation steps");
oc.doRegister("no-step-log", new Option_Bool(false));
oc.addDescription("no-step-log", "Report", "Disable console output of current simulation step");
#ifndef NO_TRACI
//remote port 0 if not used
oc.addOptionSubTopic("TraCI Server");
oc.doRegister("remote-port", new Option_Integer(0));
oc.addDescription("remote-port", "TraCI Server", "Enables TraCI Server if set");
#ifdef HAVE_PYTHON
oc.doRegister("python-script", new Option_String());
oc.addDescription("python-script", "TraCI Server", "Runs TraCI script with embedded python");
#endif
#endif
//
#ifdef HAVE_MESOSIM
oc.addOptionSubTopic("Mesoscopic");
oc.doRegister("mesosim", new Option_Bool(false));
oc.addDescription("mesosim", "Mesoscopic", "Enables mesoscopic simulation");
oc.doRegister("meso-edgelength", new Option_Float(98.0f));
oc.addDescription("meso-edgelength", "Mesoscopic", "Length of an edge segment in mesoscopic simulation");
oc.doRegister("meso-tauff", new Option_String("1.4", "TIME"));
oc.addDescription("meso-tauff", "Mesoscopic", "Factor for calculating the free-free headway time");
oc.doRegister("meso-taufj", new Option_String("1.4", "TIME"));
oc.addDescription("meso-taufj", "Mesoscopic", "Factor for calculating the free-jam headway time");
oc.doRegister("meso-taujf", new Option_String("2", "TIME"));
oc.addDescription("meso-taujf", "Mesoscopic", "Factor for calculating the jam-free headway time");
oc.doRegister("meso-taujj", new Option_String("2", "TIME"));
oc.addDescription("meso-taujj", "Mesoscopic", "Factor for calculating the jam-jam headway time");
oc.doRegister("meso-jam-threshold", new Option_Float(0.29f));
oc.addDescription("meso-jam-threshold", "Mesoscopic", "Minimum percentage of occupied space to consider a segment jammed");
oc.doRegister("meso-multi-queue", new Option_Bool(false));
oc.addDescription("meso-multi-queue", "Mesoscopic", "Enable multiple queues at edge ends");
oc.doRegister("meso-junction-control", new Option_Bool(false));
oc.addDescription("meso-junction-control", "Mesoscopic", "Enable mesoscopic traffic light and priority junction handling");
oc.doRegister("meso-recheck", new Option_String("0", "TIME"));
oc.addDescription("meso-recheck", "Mesoscopic", "Time interval for rechecking insertion into the next segment after failure");
#endif
// add rand options
RandHelper::insertRandOptions();
// add GUI options
// the reason that we include them in vanilla sumo as well is to make reusing config files easy
oc.addOptionSubTopic("GUI Only");
oc.doRegister("gui-settings-file", new Option_FileName());
oc.addDescription("gui-settings-file", "GUI Only", "Load visualisation settings from FILE");
oc.doRegister("quit-on-end", 'Q', new Option_Bool(false));
oc.addDescription("quit-on-end", "GUI Only", "Quits the GUI when the simulation stops");
oc.doRegister("game", 'G', new Option_Bool(false));
oc.addDescription("game", "GUI Only", "Start the GUI in gaming mode");
// Needed for executing the GUI without crashing (uprego 2012-08-06)
oc.doRegister("start", 'S', new Option_Bool(false));
oc.addDescription("start", "GUI Only", "Start the simulation after loading");
oc.doRegister("no-start", 'N', new Option_Bool(false));
oc.addDescription("no-start", "GUI Only", "Does not start the simulation after loading");
oc.doRegister("disable-textures", 'T', new Option_Bool(false));
oc.addDescription("disable-textures", "GUI Only", "Do not load background pictures");
// finally, add HIB options
// the reason that we include them in vanilla sumo as well is to make reusing config files easy
oc.addOptionSubTopic("HI-iberia");
/* This is currently unused, but its references are not purged */
oc.doRegister("ecoGemRouting", 'A', new Option_Bool(false));
oc.addDescription("ecoGemRouting", "HI-iberia", "Forces the EcoGem routing mode");
/* This is currently unused, but its references are not purged */
oc.doRegister("nonEcoGemRouting", 'B', new Option_Bool(false));
oc.addDescription("nonEcoGemRouting", "HI-iberia", "Forces the non EcoGem routing mode");
oc.doRegister("ARFTmode", new Option_String());
oc.addDescription("ARFTmode", "HI-iberia", "Activates the Augmented Reality"
" for Field Testing mode");
/* following the arguments:
* <vehicleId>:<adasRp>:<webServiceUrl>
* {,<vehicleId>:<adasRp>:<webServiceUrl>}
*/
/*
oc.doRegister("ARFT+mode", new Option_String());
oc.addDescription("ARFT+mode", "HI-iberia", "Activates the Augmented Reality"
" for Field Testing Plus mode");
*/
/* following the arguments:
* <vehicleId>:<adasRp>:<webServiceUrl>
* {,<vehicleId>:<adasRp>:<webServiceUrl>}
*/
oc.doRegister("RTSDGmode", new Option_String());
oc.addDescription("RTSDGmode", "HI-iberia", "Activates the Real Time Synthe"
"tic Data Generation mode");
/* following the arguments:
* <webServiceUrl>,<vehicleId>:<adasRp>
* {,<vehicleId>:<adasRp>}
*/
oc.doRegister("RTSDG+mode", new Option_String());
oc.addDescription("RTSDG+mode", "HI-iberia", "Activates the Real Time Synthe"
"tic Data Generation Plus mode");
/* following the arguments:
* <vehicleId>:<adasRp>:<webServiceUrl>
* {,<vehicleId>:<adasRp>:<webServiceUrl>}
*/
/* force initial envtemp */
oc.doRegister("fiet",new Option_Float(20.0));
oc.addDescription("fiet", "HI-iberia", "Force an initial environment temperature");
/* force initial envhum */
oc.doRegister("fieh",new Option_Float(60.0));
oc.addDescription("fieh", "HI-iberia", "Force an initial environment humidity");
/* randomize weather conditions */
oc.doRegister("rwc",new Option_Bool(false));
oc.addDescription("rwc", "HI-iberia", "Randomize weather conditions");
/* reallife weather conditions */
oc.doRegister("rlwc",new Option_Bool(false));
oc.addDescription("rlwc", "HI-iberia", "Simulate real life weather conditions");
/* randomize auxiliary services */
oc.doRegister("ras",new Option_Bool(false));
oc.addDescription("ras", "HI-iberia", "Randomize auxiliary services");
/* reallife auxiliary services */
oc.doRegister("rlas",new Option_Bool(false));
oc.addDescription("rlas", "HI-iberia", "Simulate real life auxiliary services");
/* force Germany customised simulation */
oc.doRegister("ger",new Option_Bool(false));
oc.addDescription("ger", "HI-iberia", "Simulate real life characteristics in Germany");
/* force Italy customised simulation */
oc.doRegister("ita",new Option_Bool(false));
oc.addDescription("ita", "HI-iberia", "Simulate real life characteristics in Italy");
/* Ported to SystemFrame.cpp
oc.doRegister("verbosity", 'L', new Option_Integer(0));
oc.addDescription("verbosity", "HI-Iberia", "Adjust the verbosity level of SUMO HIB debug messages");
*/
}
// ===========================================================================
// method definitions
// ===========================================================================
void
MSFrame::fillOptions() {
OptionsCont& oc = OptionsCont::getOptions();
oc.addCallExample("-b 0 -e 1000 -n net.xml -r routes.xml", "start a simulation from time 0 to 1000 with given net and routes");
oc.addCallExample("-c munich_config.cfg", "start with a configuration file");
oc.addCallExample("--help", "print help");
// insert options sub-topics
SystemFrame::addConfigurationOptions(oc); // fill this subtopic, too
oc.addOptionSubTopic("Input");
oc.addOptionSubTopic("Output");
oc.addOptionSubTopic("Time");
oc.addOptionSubTopic("Processing");
oc.addOptionSubTopic("Routing");
SystemFrame::addReportOptions(oc); // fill this subtopic, too
// register configuration options
// register input options
oc.doRegister("net-file", 'n', new Option_FileName());
oc.addSynonyme("net-file", "net");
oc.addDescription("net-file", "Input", "Load road network description from FILE");
oc.addXMLDefault("net-file", "net");
oc.doRegister("route-files", 'r', new Option_FileName());
oc.addSynonyme("route-files", "routes");
oc.addDescription("route-files", "Input", "Load routes descriptions from FILE(s)");
oc.doRegister("additional-files", 'a', new Option_FileName());
oc.addSynonyme("additional-files", "additional");
oc.addDescription("additional-files", "Input", "Load further descriptions from FILE(s)");
oc.doRegister("weight-files", 'w', new Option_FileName());
oc.addSynonyme("weight-files", "weights");
oc.addDescription("weight-files", "Input", "Load edge/lane weights for online rerouting from FILE");
oc.doRegister("weight-attribute", 'x', new Option_String("traveltime"));
oc.addSynonyme("weight-attribute", "measure", true);
oc.addDescription("weight-attribute", "Input", "Name of the xml attribute which gives the edge weight");
oc.doRegister("load-state", new Option_FileName());//!!! check, describe
oc.addDescription("load-state", "Input", "Loads a network state from FILE");
oc.doRegister("load-state.offset", new Option_String("0", "TIME"));//!!! check, describe
oc.addDescription("load-state.offset", "Input", "Shifts all times loaded from a saved state by the given offset");
// register output options
oc.doRegister("netstate-dump", new Option_FileName());
oc.addSynonyme("netstate-dump", "ndump");
oc.addSynonyme("netstate-dump", "netstate");
oc.addSynonyme("netstate-dump", "netstate-output");
oc.addDescription("netstate-dump", "Output", "Save complete network states into FILE");
oc.doRegister("netstate-dump.empty-edges", new Option_Bool(false));
oc.addSynonyme("netstate-dump.empty-edges", "netstate.empty-edges");
oc.addSynonyme("netstate-dump.empty-edges", "netstate-output.empty-edges");
oc.addSynonyme("netstate-dump.empty-edges", "dump-empty-edges", true);
oc.addDescription("netstate-dump.empty-edges", "Output", "Write also empty edges completely when dumping");
oc.doRegister("netstate-dump.precision", new Option_Integer(OUTPUT_ACCURACY));
oc.addSynonyme("netstate-dump.precision", "netstate.precision");
oc.addSynonyme("netstate-dump.precision", "netstate-output.precision");
oc.addSynonyme("netstate-dump.precision", "dump-precision", true);
oc.addDescription("netstate-dump.precision", "Output", "Write positions and speeds with the given precision (default 2)");
oc.doRegister("emission-output", new Option_FileName());
oc.addDescription("emission-output", "Output", "Save the emission values of each vehicle");
oc.doRegister("emission-output.precision", new Option_Integer(OUTPUT_ACCURACY));
oc.addDescription("emission-output.precision", "Output", "Write emission values with the given precision (default 2)");
oc.doRegister("battery-output", new Option_FileName());
oc.addDescription("battery-output", "Output", "Save the battery values of each vehicle");
oc.doRegister("battery-output.precision", new Option_Integer(OUTPUT_ACCURACY));
oc.addDescription("battery-output.precision", "Output", "Write battery values with the given precision (default 2)");
oc.doRegister("fcd-output", new Option_FileName());
oc.addDescription("fcd-output", "Output", "Save the Floating Car Data");
oc.doRegister("fcd-output.geo", new Option_Bool(false));
oc.addDescription("fcd-output.geo", "Output", "Save the Floating Car Data using geo-coordinates (lon/lat)");
oc.doRegister("fcd-output.signals", new Option_Bool(false));
oc.addDescription("fcd-output.signals", "Output", "Add the vehicle signal state to the FCD output (brake lights etc.)");
oc.doRegister("full-output", new Option_FileName());
oc.addDescription("full-output", "Output", "Save a lot of information for each timestep (very redundant)");
oc.doRegister("queue-output", new Option_FileName());
oc.addDescription("queue-output", "Output", "Save the vehicle queues at the junctions (experimental)");
oc.doRegister("vtk-output", new Option_FileName());
oc.addDescription("vtk-output", "Output", "Save complete vehicle positions inclusive speed values in the VTK Format (usage: /path/out will produce /path/out_$TIMESTEP$.vtp files)");
oc.doRegister("amitran-output", new Option_FileName());
oc.addDescription("amitran-output", "Output", "Save the vehicle trajectories in the Amitran format");
oc.doRegister("summary-output", new Option_FileName());
oc.addSynonyme("summary-output", "summary");
oc.addDescription("summary-output", "Output", "Save aggregated vehicle departure info into FILE");
oc.doRegister("tripinfo-output", new Option_FileName());
oc.addSynonyme("tripinfo-output", "tripinfo");
oc.addDescription("tripinfo-output", "Output", "Save single vehicle trip info into FILE");
oc.doRegister("tripinfo-output.write-unfinished", new Option_Bool(false));
oc.addDescription("tripinfo-output.write-unfinished", "Output", "Write tripinfo output for vehicles which have not arrived at simulation end");
oc.doRegister("vehroute-output", new Option_FileName());
oc.addSynonyme("vehroute-output", "vehroutes");
oc.addDescription("vehroute-output", "Output", "Save single vehicle route info into FILE");
oc.doRegister("vehroute-output.exit-times", new Option_Bool(false));
oc.addSynonyme("vehroute-output.exit-times", "vehroutes.exit-times");
oc.addDescription("vehroute-output.exit-times", "Output", "Write the exit times for all edges");
oc.doRegister("vehroute-output.last-route", new Option_Bool(false));
oc.addSynonyme("vehroute-output.last-route", "vehroutes.last-route");
oc.addDescription("vehroute-output.last-route", "Output", "Write the last route only");
oc.doRegister("vehroute-output.sorted", new Option_Bool(false));
oc.addSynonyme("vehroute-output.sorted", "vehroutes.sorted");
oc.addDescription("vehroute-output.sorted", "Output", "Sorts the output by departure time");
oc.doRegister("vehroute-output.dua", new Option_Bool(false));
oc.addSynonyme("vehroute-output.dua", "vehroutes.dua");
oc.addDescription("vehroute-output.dua", "Output", "Write the output in the duarouter alternatives style");
oc.doRegister("vehroute-output.intended-depart", new Option_Bool(false));
oc.addSynonyme("vehroute-output.intended-depart", "vehroutes.intended-depart");
oc.addDescription("vehroute-output.intended-depart", "Output", "Write the output with the intended instead of the real departure time");
oc.doRegister("vehroute-output.route-length", new Option_Bool(false));
oc.addSynonyme("vehroute-output.route-length", "vehroutes.route-length");
oc.addDescription("vehroute-output.route-length", "Output", "Include total route length in the output");
oc.doRegister("vehroute-output.write-unfinished", new Option_Bool(false));
oc.addDescription("vehroute-output.write-unfinished", "Output", "Write vehroute output for vehicles which have not arrived at simulation end");
oc.doRegister("link-output", new Option_FileName());
oc.addDescription("link-output", "Output", "Save links states into FILE");
oc.doRegister("bt-output", new Option_FileName());
oc.addDescription("bt-output", "Output", "Save bluetooth visibilities into FILE (in conjunction with device.btreceiver and device.btsender)");
oc.doRegister("lanechange-output", new Option_FileName());
oc.addDescription("lanechange-output", "Output", "Record lane changes and their motivations for all vehicles into FILE");
#ifdef _DEBUG
oc.doRegister("movereminder-output", new Option_FileName());
oc.addDescription("movereminder-output", "Output", "Save movereminder states of selected vehicles into FILE");
oc.doRegister("movereminder-output.vehicles", new Option_String());
oc.addDescription("movereminder-output.vehicles", "Output", "List of vehicle ids which shall save their movereminder states");
#endif
oc.doRegister("save-state.times", new Option_IntVector(IntVector()));//!!! check, describe
oc.addDescription("save-state.times", "Output", "Use INT[] as times at which a network state written");
oc.doRegister("save-state.prefix", new Option_FileName("state"));//!!! check, describe
oc.addDescription("save-state.prefix", "Output", "Prefix for network states");
oc.doRegister("save-state.files", new Option_FileName());//!!! check, describe
oc.addDescription("save-state.files", "Output", "Files for network states");
// register the simulation settings
oc.doRegister("begin", 'b', new Option_String("0", "TIME"));
oc.addDescription("begin", "Time", "Defines the begin time in seconds; The simulation starts at this time");
oc.doRegister("end", 'e', new Option_String("-1", "TIME"));
oc.addDescription("end", "Time", "Defines the end time in seconds; The simulation ends at this time");
oc.doRegister("step-length", new Option_String("1", "TIME"));
oc.addDescription("step-length", "Time", "Defines the step duration in seconds");
oc.doRegister("lateral-resolution", new Option_Float(-1));
oc.addDescription("lateral-resolution", "Processing", "Defines the resolution in m when handling lateral positioning within a lane (with -1 all vehicles drive at the center of their lane");
// register the processing options
oc.doRegister("route-steps", 's', new Option_String("200", "TIME"));
oc.addDescription("route-steps", "Processing", "Load routes for the next number of seconds ahead");
#ifdef HAVE_INTERNAL_LANES
oc.doRegister("no-internal-links", new Option_Bool(false));
oc.addDescription("no-internal-links", "Processing", "Disable (junction) internal links");
oc.doRegister("ignore-junction-blocker", new Option_String("-1", "TIME"));
oc.addDescription("ignore-junction-blocker", "Processing", "Ignore vehicles which block the junction after they have been standing for SECONDS (-1 means never ignore)");
#endif
oc.doRegister("ignore-route-errors", new Option_Bool(false));
oc.addDescription("ignore-route-errors", "Processing", "Do not check whether routes are connected");
oc.doRegister("ignore-accidents", new Option_Bool(false));
oc.addDescription("ignore-accidents", "Processing", "Do not check whether accidents occur");
oc.doRegister("collision.action", new Option_String("teleport"));
oc.addDescription("collision.action", "Processing", "How to deal with collisions: [none,warn,teleport,remove]");
oc.doRegister("collision.check-junctions", new Option_Bool(false));
oc.addDescription("collision.check-junctions", "Processing", "Enables collisions checks on junctions");
oc.doRegister("max-num-vehicles", new Option_Integer(-1));
oc.addDescription("max-num-vehicles", "Processing", "Delay vehicle insertion to stay within the given maximum number");
oc.doRegister("scale", new Option_Float());
oc.addDescription("scale", "Processing", "Scale demand by the given factor (by discarding or duplicating vehicles)");
oc.doRegister("time-to-teleport", new Option_String("300", "TIME"));
oc.addDescription("time-to-teleport", "Processing", "Specify how long a vehicle may wait until being teleported, defaults to 300, non-positive values disable teleporting");
oc.doRegister("time-to-teleport.highways", new Option_String("0", "TIME"));
oc.addDescription("time-to-teleport.highways", "Processing", "The waiting time after which vehicles on a fast road (speed > 69m/s) are teleported if they are on a non-continuing lane");
oc.doRegister("waiting-time-memory", new Option_String("100", "TIME"));
oc.addDescription("waiting-time-memory", "Processing", "Length of time interval, over which accumulated waiting time is taken into account");
oc.doRegister("max-depart-delay", new Option_String("-1", "TIME"));
oc.addDescription("max-depart-delay", "Processing", "How long vehicles wait for departure before being skipped, defaults to -1 which means vehicles are never skipped");
oc.doRegister("sloppy-insert", new Option_Bool(false));
oc.addDescription("sloppy-insert", "Processing", "Whether insertion on an edge shall not be repeated in same step once failed");
oc.doRegister("eager-insert", new Option_Bool(false));
oc.addDescription("eager-insert", "Processing", "Whether each vehicle is checked separately for insertion on an edge");
oc.doRegister("random-depart-offset", new Option_String("0", "TIME"));
oc.addDescription("random-depart-offset", "Processing", "Each vehicle receives a random offset to its depart value drawn uniformly from [0, TIME]");
oc.doRegister("lanechange.allow-swap", new Option_Bool(false));
oc.addDescription("lanechange.allow-swap", "Processing", "Whether blocking vehicles trying to change lanes may be swapped");
oc.doRegister("lanechange.duration", new Option_String("0", "TIME"));
oc.addDescription("lanechange.duration", "Processing", "Duration of a lane change maneuver (default 0)");
oc.doRegister("lanechange.overtake-right", new Option_Bool(false));
oc.addDescription("lanechange.overtake-right", "Processing", "Whether overtaking on the right on motorways is permitted");
oc.doRegister("tls.all-off", new Option_Bool(false));
oc.addDescription("tls.all-off", "Processing", "Switches off all traffic lights.");
// pedestrian model
oc.doRegister("pedestrian.model", new Option_String("striping"));
oc.addDescription("pedestrian.model", "Processing", "Select among pedestrian models ['nonInteracting', 'striping']");
oc.doRegister("pedestrian.striping.stripe-width", new Option_Float(0.65));
oc.addDescription("pedestrian.striping.stripe-width", "Processing", "Width of parallel stripes for segmenting a sidewalk (meters) for use with model 'striping'");
oc.doRegister("pedestrian.striping.dawdling", new Option_Float(0.2));
oc.addDescription("pedestrian.striping.dawdling", "Processing", "factor for random slow-downs [0,1] for use with model 'striping'");
oc.doRegister("pedestrian.striping.jamtime", new Option_String("300", "TIME"));
oc.addDescription("pedestrian.striping.jamtime", "Processing", "Time in seconds after which pedestrians start squeezing through a jam when using model 'striping' (non-positive values disable squeezing)");
// generic routing options
oc.doRegister("routing-algorithm", new Option_String("dijkstra"));
oc.addDescription("routing-algorithm", "Routing",
"Select among routing algorithms ['dijkstra', 'astar', 'CH', 'CHWrapper']");
oc.doRegister("weights.random-factor", new Option_Float(1.));
oc.addDescription("weights.random-factor", "Routing", "Edge weights for routing are dynamically disturbed by a random factor drawn uniformly from [1,FLOAT)");
// devices
oc.addOptionSubTopic("Emissions");
oc.doRegister("phemlight-path", new Option_FileName("./PHEMlight/"));
oc.addDescription("phemlight-path", "Emissions", "Determines where to load PHEMlight definitions from.");
oc.addOptionSubTopic("Communication");
oc.addOptionSubTopic("Battery");
MSDevice::insertOptions(oc);
// register report options
oc.doRegister("duration-log.disable", new Option_Bool(false));
oc.addSynonyme("duration-log.disable", "no-duration-log", false);
oc.addDescription("duration-log.disable", "Report", "Disable performance reports for individual simulation steps");
oc.doRegister("duration-log.statistics", new Option_Bool(false));
oc.addDescription("duration-log.statistics", "Report", "Enable statistics on vehicle trips");
oc.doRegister("no-step-log", new Option_Bool(false));
oc.addDescription("no-step-log", "Report", "Disable console output of current simulation step");
#ifndef NO_TRACI
//remote port 0 if not used
oc.addOptionSubTopic("TraCI Server");
oc.doRegister("remote-port", new Option_Integer(0));
oc.addDescription("remote-port", "TraCI Server", "Enables TraCI Server if set");
#ifdef HAVE_PYTHON
oc.doRegister("python-script", new Option_String());
oc.addDescription("python-script", "TraCI Server", "Runs TraCI script with embedded python");
#endif
#endif
//
oc.addOptionSubTopic("Mesoscopic");
oc.doRegister("mesosim", new Option_Bool(false));
oc.addDescription("mesosim", "Mesoscopic", "Enables mesoscopic simulation");
oc.doRegister("meso-edgelength", new Option_Float(98.0f));
oc.addDescription("meso-edgelength", "Mesoscopic", "Length of an edge segment in mesoscopic simulation");
oc.doRegister("meso-tauff", new Option_String("1.13", "TIME"));
oc.addDescription("meso-tauff", "Mesoscopic", "Factor for calculating the net free-free headway time");
oc.doRegister("meso-taufj", new Option_String("1.13", "TIME"));
oc.addDescription("meso-taufj", "Mesoscopic", "Factor for calculating the net free-jam headway time");
oc.doRegister("meso-taujf", new Option_String("2", "TIME"));
oc.addDescription("meso-taujf", "Mesoscopic", "Factor for calculating the jam-free headway time");
oc.doRegister("meso-taujj", new Option_String("1.4", "TIME"));
oc.addDescription("meso-taujj", "Mesoscopic", "Factor for calculating the jam-jam headway time");
oc.doRegister("meso-jam-threshold", new Option_Float(-1));
oc.addDescription("meso-jam-threshold", "Mesoscopic",
"Minimum percentage of occupied space to consider a segment jammed. A negative argument causes thresholds to be computed based on edge speed and tauff (default)");
oc.doRegister("meso-multi-queue", new Option_Bool(true));
oc.addDescription("meso-multi-queue", "Mesoscopic", "Enable multiple queues at edge ends");
oc.doRegister("meso-junction-control", new Option_Bool(false));
oc.addDescription("meso-junction-control", "Mesoscopic", "Enable mesoscopic traffic light and priority junction handling");
oc.doRegister("meso-junction-control.limited", new Option_Bool(false));
oc.addDescription("meso-junction-control.limited", "Mesoscopic",
"Enable mesoscopic traffic light and priority junction handling for saturated links. This prevents faulty traffic lights from hindering flow in low-traffic situations");
oc.doRegister("meso-tls-penalty", new Option_Float(0));
oc.addDescription("meso-tls-penalty", "Mesoscopic",
"Apply scaled time penalties when driving across tls controlled junctions based on green split instead of checking actual phases");
oc.doRegister("meso-overtaking", new Option_Bool(false));
oc.addDescription("meso-overtaking", "Mesoscopic", "Enable mesoscopic overtaking");
oc.doRegister("meso-recheck", new Option_String("0", "TIME"));
oc.addDescription("meso-recheck", "Mesoscopic", "Time interval for rechecking insertion into the next segment after failure");
// add rand options
RandHelper::insertRandOptions();
// add GUI options
// the reason that we include them in vanilla sumo as well is to make reusing config files easy
oc.addOptionSubTopic("GUI Only");
oc.doRegister("gui-settings-file", new Option_FileName());
oc.addDescription("gui-settings-file", "GUI Only", "Load visualisation settings from FILE");
oc.doRegister("quit-on-end", 'Q', new Option_Bool(false));
oc.addDescription("quit-on-end", "GUI Only", "Quits the GUI when the simulation stops");
oc.doRegister("game", 'G', new Option_Bool(false));
oc.addDescription("game", "GUI Only", "Start the GUI in gaming mode");
oc.doRegister("start", 'S', new Option_Bool(false));
oc.addDescription("start", "GUI Only", "Start the simulation after loading");
oc.doRegister("demo", 'D', new Option_Bool(false));
oc.addDescription("demo", "GUI Only", "Restart the simulation after ending (demo mode)");
oc.doRegister("disable-textures", 'T', new Option_Bool(false));
oc.addDescription("disable-textures", "GUI Only", "Do not load background pictures");
#ifdef HAVE_OSG
oc.doRegister("osg-view", new Option_Bool(false));
oc.addDescription("osg-view", "GUI Only", "Start with an OpenSceneGraph view instead of the regular 2D view");
#endif
}
