MSE3Collector Class Reference

#include <MSE3Collector.h>

Inheritance diagram for MSE3Collector:

MSDetectorFileOutput MSVehicleQuitReminded GUIE3Collector

Detailed Description

A detector of vehicles passing an area between entry/exit points.

E3-detectors are defined by a set of in-cross-sections and out-cross-sections. Vehicles, that pass an in- and out-cross-section are detected when they pass the out-cross-section. Vehicles passing the out-cross-section without having passed the in-cross-section are not detected.

Definition at line 59 of file MSE3Collector.h.


Public Member Functions

void enter (MSVehicle &veh, SUMOReal entryTimestep) throw ()
 Called if a vehicle touches an entry-cross-section.
const std::string & getID () const throw ()
 Returns the id of the detector.
void leave (MSVehicle &veh, SUMOReal leaveTimestep) throw ()
 Called if a vehicle passes a leave-cross-section.
 MSE3Collector (const std::string &id, const CrossSectionVector &entries, const CrossSectionVector &exits, MetersPerSecond haltingSpeedThreshold, SUMOTime haltingTimeThreshold) throw ()
 Constructor.
void reset () throw ()
 Resets all generated values to allow computation of next interval.
void update (SUMOTime currentTime) throw ()
 Computes the detector values in each time step.
virtual ~MSE3Collector () throw ()
 Destructor.
Methods returning current values
SUMOReal getCurrentHaltingNumber () const throw ()
 Returns the number of current haltings within the area.
SUMOReal getCurrentMeanSpeed () const throw ()
 Returns the mean speed within the area.
std::vector< std::string > getCurrentVehicleIDs () const throw ()
 Returns the number of vehicles within the area.
SUMOReal getVehiclesWithin () const throw ()
 Returns the number of vehicles within the area.
Methods inherited from MSVehicleQuitReminded.
void removeOnTripEnd (MSVehicle *veh) throw ()
 Removes a vehicle which entered the area but quitted before leaving it.
Methods inherited from MSDetectorFileOutput.
void writeXMLDetectorProlog (OutputDevice &dev) const throw (IOError)
 Opens the XML-output using "e3-detector" as root element.
void writeXMLOutput (OutputDevice &dev, SUMOTime startTime, SUMOTime stopTime) throw (IOError)
 Writes collected values into the given stream.

Protected Attributes

std::map< MSVehicle *, E3Values > myEnteredContainer
 Container for vehicles that have entered the area.
CrossSectionVector myEntries
 The detector's entries.
std::vector< MSE3EntryReminder * > myEntryReminders
 The detector's built entry reminder.
CrossSectionVector myExits
 The detector's exits.
MetersPerSecond myHaltingSpeedThreshold
 Speed-threshold to determine if a vehicle is halting.
SUMOTime myHaltingTimeThreshold
std::string myID
 The detector's id.
SUMOTime myLastResetTime
 Information when the last reset has been done.
std::vector< MSE3LeaveReminder * > myLeaveReminders
 The detector's built exit reminder.
std::map< MSVehicle *, E3Values > myLeftContainer
 Container for vehicles that have left the area.
Storages for current values
SUMOReal myCurrentHaltingsNumber
 The current number of haltings (inside).
SUMOReal myCurrentMeanSpeed
 The current mean speed of known vehicles (inside).
SUMOReal myCurrentTouchedVehicles
 The current number of vehicles inside;.

Private Member Functions

 MSE3Collector (const MSE3Collector &)
 Invalidated copy constructor.
MSE3Collector & operator= (const MSE3Collector &)
 Invalidated assignment operator.

Data Structures

struct  E3Values
 Internal storage for values from a vehicle. More...
class  MSE3EntryReminder
 A place on the road net (at a certain lane and position on it) where the E3-area begins. More...
class  MSE3LeaveReminder
 A place on the road net (at a certain lane and position on it) where the E3-area ends. More...

Constructor & Destructor Documentation

MSE3Collector::MSE3Collector ( const std::string &  id,
const CrossSectionVector &  entries,
const CrossSectionVector &  exits,
MetersPerSecond  haltingSpeedThreshold,
SUMOTime  haltingTimeThreshold 
) throw ()

Constructor.

Sets reminder objects on entry- and leave-lanes

Parameters:
[in] id The detector's unique id.
[in] entries Entry-cross-sections.
[in] exits Leavey-cross-sections.
[in] haltingSpeedThreshold A vehicle must not drive a greater speed than haltingSpeedThreshold to be a "halting" vehicle.
[in] haltingTimeThreshold A vehicle must not drive a greater speed for more than haltingTimeThreshold to be a "halting" vehicle.

Definition at line 117 of file MSE3Collector.cpp.

References MSE3Collector::MSE3LeaveReminder::MSE3LeaveReminder(), myEntryReminders, myLeaveReminders, and reset().

00122         : myID(id), myEntries(entries), myExits(exits),
00123         myHaltingTimeThreshold(haltingTimeThreshold), myHaltingSpeedThreshold(haltingSpeedThreshold),
00124         myCurrentMeanSpeed(0), myCurrentHaltingsNumber(0), myCurrentTouchedVehicles(0),
00125         myLastResetTime(-1) {
00126     // Set MoveReminders to entries and exits
00127     for (CrossSectionVectorConstIt crossSec1 = entries.begin(); crossSec1!=entries.end(); ++crossSec1) {
00128         myEntryReminders.push_back(new MSE3EntryReminder(*crossSec1, *this));
00129     }
00130     for (CrossSectionVectorConstIt crossSec2 = exits.begin(); crossSec2!=exits.end(); ++crossSec2) {
00131         myLeaveReminders.push_back(new MSE3LeaveReminder(*crossSec2, *this));
00132     }
00133     reset();
00134 }

MSE3Collector::~MSE3Collector (  )  throw () [virtual]

Destructor.

Definition at line 137 of file MSE3Collector.cpp.

References myEnteredContainer, myEntryReminders, and myLeaveReminders.

00137                                       {
00138     for (std::map<MSVehicle*, E3Values>::iterator pair = myEnteredContainer.begin(); pair!=myEnteredContainer.end(); ++pair) {
00139         pair->first->quitRemindedLeft(this);
00140     }
00141     for (std::vector<MSE3EntryReminder*>::iterator i = myEntryReminders.begin(); i!=myEntryReminders.end(); ++i) {
00142         delete *i;
00143     }
00144     for (std::vector<MSE3LeaveReminder*>::iterator i = myLeaveReminders.begin(); i!=myLeaveReminders.end(); ++i) {
00145         delete *i;
00146     }
00147 }

MSE3Collector::MSE3Collector ( const MSE3Collector &   )  [private]

Invalidated copy constructor.

Member Function Documentation

void MSE3Collector::enter ( MSVehicle &  veh,
SUMOReal  entryTimestep 
) throw ()

Called if a vehicle touches an entry-cross-section.

Inserts vehicle into internal containers.

Parameters:
[in] veh The vehicle that entered the area
[in] entryTimestep The time step the vehicle entered the area

Definition at line 158 of file MSE3Collector.cpp.

References DELTA_T, MSE3Collector::E3Values::entryTime, getID(), MsgHandler::getWarningInstance(), MSE3Collector::E3Values::hadUpdate, MSE3Collector::E3Values::haltingBegin, MSE3Collector::E3Values::haltings, MsgHandler::inform(), MSE3Collector::E3Values::intervalHaltings, MSE3Collector::E3Values::intervalSpeedSum, MSE3Collector::E3Values::leaveTime, myEnteredContainer, myHaltingSpeedThreshold, myHaltingTimeThreshold, MSE3Collector::E3Values::speedSum, and SUMOReal.

00158                                                                    {
00159     if (myEnteredContainer.find(&veh)!=myEnteredContainer.end()) {
00160         MsgHandler::getWarningInstance()->inform("Vehicle '" + veh.getID() + "' reentered E3-detector '" + getID() + "'.");
00161         return;
00162     }
00163     veh.quitRemindedEntered(this);
00164     SUMOReal entryTimestepFraction = ((SUMOReal) DELTA_T - fmod(entryTimestep * 1000., 1000.)) / (SUMOReal) DELTA_T;
00165     SUMOReal speedFraction = (veh.getSpeed() * entryTimestepFraction);
00166     E3Values v;
00167     v.entryTime = entryTimestep;
00168     v.leaveTime = 0;
00169     v.speedSum = speedFraction / (1000. / (SUMOReal) DELTA_T);
00170     v.haltingBegin = veh.getSpeed() < myHaltingSpeedThreshold ? entryTimestep : -1;
00171     v.intervalSpeedSum = speedFraction / (1000. / (SUMOReal) DELTA_T);
00172     v.haltings = 0;
00173     v.intervalHaltings = 0;
00174     if (veh.getSpeed() < myHaltingSpeedThreshold) {
00175         if (1.-entryTimestepFraction>myHaltingTimeThreshold) {
00176             v.haltings++;
00177             v.intervalHaltings++;
00178         }
00179     }
00180     v.hadUpdate = false;
00181     myEnteredContainer[&veh] = v;
00182 }

SUMOReal MSE3Collector::getCurrentHaltingNumber (  )  const throw ()

Returns the number of current haltings within the area.

If no vehicle is within the area, 0 is returned.

Returns:
The mean number of haltings within the area

Definition at line 357 of file MSE3Collector.cpp.

References myCurrentHaltingsNumber.

Referenced by GUIE3Collector::MyWrapper::getParameterWindow(), and TraCIServerAPI_MeMeDetector::processGet().

00357                                                      {
00358     return myCurrentHaltingsNumber;
00359 }

SUMOReal MSE3Collector::getCurrentMeanSpeed (  )  const throw ()

Returns the mean speed within the area.

If no vehicle is within the area, -1 is returned.

Returns:
The mean speed [m/s] of all vehicles within the area, -1 if there is none

Definition at line 344 of file MSE3Collector.cpp.

References myEnteredContainer, and SUMOReal.

Referenced by GUIE3Collector::MyWrapper::getParameterWindow(), and TraCIServerAPI_MeMeDetector::processGet().

00344                                                  {
00345     SUMOReal ret = 0;
00346     if (myEnteredContainer.size()==0) {
00347         return -1;
00348     }
00349     for (std::map<MSVehicle*, E3Values>::const_iterator pair = myEnteredContainer.begin(); pair!=myEnteredContainer.end(); ++pair) {
00350         ret += (*pair).first->getSpeed();
00351     }
00352     return ret / SUMOReal(myEnteredContainer.size());
00353 }

std::vector< std::string > MSE3Collector::getCurrentVehicleIDs (  )  const throw ()

Returns the number of vehicles within the area.

Returns:
The number of vehicles that have passed the entry, but not yet an exit point

Definition at line 369 of file MSE3Collector.cpp.

References myEnteredContainer.

Referenced by TraCIServerAPI_MeMeDetector::processGet().

00369                                                   {
00370     std::vector<std::string> ret;
00371     for (std::map<MSVehicle*, E3Values>::const_iterator pair = myEnteredContainer.begin(); pair!=myEnteredContainer.end(); ++pair) {
00372         ret.push_back((*pair).first->getID());
00373     }
00374     std::sort(ret.begin(), ret.end());
00375     return ret;
00376 }

const std::string & MSE3Collector::getID (  )  const throw ()

Returns the id of the detector.

Returns:
The id of the detector

Definition at line 215 of file MSE3Collector.cpp.

References myID.

Referenced by enter(), GUIE3Collector::MyWrapper::getMicrosimID(), leave(), and removeOnTripEnd().

00215                                    {
00216     return myID;
00217 }

SUMOReal MSE3Collector::getVehiclesWithin (  )  const throw ()

Returns the number of vehicles within the area.

Returns:
The number of vehicles that passed the entry collector

Definition at line 363 of file MSE3Collector.cpp.

References myEnteredContainer, and SUMOReal.

Referenced by GUIE3Collector::MyWrapper::getParameterWindow(), and TraCIServerAPI_MeMeDetector::processGet().

00363                                                {
00364     return (SUMOReal) myEnteredContainer.size();
00365 }

void MSE3Collector::leave ( MSVehicle &  veh,
SUMOReal  leaveTimestep 
) throw ()

Called if a vehicle passes a leave-cross-section.

Removes vehicle from internal containers.

Parameters:
[in] veh The vehicle that left the area
[in] entryTimestep The time step the vehicle left the area

Definition at line 186 of file MSE3Collector.cpp.

References DELTA_T, getID(), MsgHandler::getWarningInstance(), MSE3Collector::E3Values::hadUpdate, MSE3Collector::E3Values::haltingBegin, MSE3Collector::E3Values::haltings, MsgHandler::inform(), MSE3Collector::E3Values::intervalHaltings, MSE3Collector::E3Values::intervalSpeedSum, MSE3Collector::E3Values::leaveTime, myEnteredContainer, myHaltingSpeedThreshold, myHaltingTimeThreshold, myLeftContainer, MSE3Collector::E3Values::speedSum, and SUMOReal.

Referenced by MSE3Collector::MSE3LeaveReminder::isStillActive().

00186                                                                    {
00187     if (myEnteredContainer.find(&veh)==myEnteredContainer.end()) {
00188         MsgHandler::getWarningInstance()->inform("Vehicle '" + veh.getID() + "' left E3-detector '" + getID() + "' before entering it.");
00189     } else {
00190         E3Values values = myEnteredContainer[&veh];
00191         values.leaveTime = leaveTimestep;
00192         SUMOReal leaveTimestepFraction = leaveTimestep - (SUMOReal)((int) leaveTimestep);
00193         leaveTimestepFraction = fmod(leaveTimestep * 1000., 1000.) / (SUMOReal) DELTA_T;
00194         if (values.hadUpdate) {
00195             SUMOReal speedFraction = (veh.getSpeed() * leaveTimestepFraction);
00196             values.speedSum += speedFraction / (1000. / (SUMOReal) DELTA_T);
00197             values.intervalSpeedSum += speedFraction / (1000. / (SUMOReal) DELTA_T);
00198             if (veh.getSpeed() < myHaltingSpeedThreshold && values.haltingBegin!=-1 && leaveTimestep-values.haltingBegin>myHaltingTimeThreshold) {
00199                 values.haltings++;
00200                 values.intervalHaltings++;
00201             }
00202         } else {
00203             SUMOReal speedFraction = (veh.getSpeed() * SUMOReal(1. - leaveTimestepFraction));
00204             values.speedSum -= speedFraction / (1000. / (SUMOReal) DELTA_T);
00205             values.intervalSpeedSum -= speedFraction / (1000. / (SUMOReal) DELTA_T);
00206         }
00207         myEnteredContainer.erase(&veh);
00208         myLeftContainer[&veh] = values;
00209     }
00210     veh.quitRemindedLeft(this);
00211 }

MSE3Collector& MSE3Collector::operator= ( const MSE3Collector &   )  [private]

Invalidated assignment operator.

void MSE3Collector::removeOnTripEnd ( MSVehicle *  veh  )  throw () [virtual]

Removes a vehicle which entered the area but quitted before leaving it.

Remove vehicles that entered the detector but reached their destination before passing the leave-cross-section from internal containers.

Parameters:
[in] veh The vehicle to remove

Implements MSVehicleQuitReminded.

Definition at line 221 of file MSE3Collector.cpp.

References getID(), MsgHandler::getWarningInstance(), MsgHandler::inform(), and myEnteredContainer.

00221                                                      {
00222     if (myEnteredContainer.find(veh)==myEnteredContainer.end()) {
00223         MsgHandler::getWarningInstance()->inform("Vehicle '" + veh->getID() + "' left E3-detector '" + getID() + "' before entering it.");
00224     } else {
00225         myEnteredContainer.erase(veh);
00226     }
00227 }

void MSE3Collector::reset (  )  throw () [virtual]

Resets all generated values to allow computation of next interval.

Reimplemented from MSDetectorFileOutput.

Definition at line 151 of file MSE3Collector.cpp.

References myLeftContainer.

Referenced by MSE3Collector().

00151                              {
00152     myLeftContainer.clear();
00153 }

void MSE3Collector::update ( SUMOTime  currentTime  )  throw ()

Computes the detector values in each time step.

This method should be called at the end of a simulation step, when all vehicles have moved. The current values are computed and summed up with the previous.

Parameters:
[in] currentTime The current simulation time (unused)

Definition at line 304 of file MSE3Collector.cpp.

References MSE3Collector::E3Values::entryTime, MSVehicle::getSpeed(), MSE3Collector::E3Values::hadUpdate, MSE3Collector::E3Values::haltingBegin, MSE3Collector::E3Values::haltings, MSE3Collector::E3Values::intervalHaltings, MSE3Collector::E3Values::intervalSpeedSum, myCurrentHaltingsNumber, myCurrentMeanSpeed, myCurrentTouchedVehicles, myEnteredContainer, myHaltingSpeedThreshold, myHaltingTimeThreshold, MSE3Collector::E3Values::speedSum, SUMOReal, and TS.

00304                                                {
00305     myCurrentMeanSpeed = 0;
00306     myCurrentHaltingsNumber = 0;
00307     myCurrentTouchedVehicles = 0;
00308     for (std::map<MSVehicle*, E3Values>::iterator pair = myEnteredContainer.begin(); pair!=myEnteredContainer.end(); ++pair) {
00309         MSVehicle* veh = pair->first;
00310         E3Values& values = pair->second;
00311         values.hadUpdate = true;
00312         if (values.entryTime*1000.>=execTime) {
00313             // vehicle entered at this time step
00314             SUMOReal fraction = execTime + 1. - values.entryTime;
00315             myCurrentMeanSpeed += fraction * veh->getSpeed();
00316             myCurrentTouchedVehicles += fraction;
00317             if (values.haltingBegin>=0) {
00318                 myCurrentHaltingsNumber++;
00319             }
00320             continue;
00321         }
00322         values.speedSum += veh->getSpeed() * TS;
00323         values.intervalSpeedSum += veh->getSpeed() * TS;
00324         myCurrentMeanSpeed += veh->getSpeed();
00325         myCurrentTouchedVehicles += 1;
00326         if (veh->getSpeed() < myHaltingSpeedThreshold) {
00327             if (values.haltingBegin==-1) {
00328                 values.haltingBegin = execTime;
00329             }
00330             if (execTime-values.haltingBegin>myHaltingTimeThreshold) {
00331                 values.haltings++;
00332                 values.intervalHaltings++;
00333                 myCurrentHaltingsNumber++;
00334             }
00335         } else {
00336             values.haltingBegin = -1;
00337         }
00338         myCurrentMeanSpeed /= myCurrentTouchedVehicles;
00339     }
00340 }

void MSE3Collector::writeXMLDetectorProlog ( OutputDevice &  dev  )  const throw (IOError) [virtual]

Opens the XML-output using "e3-detector" as root element.

The lists of entries/exists are written, too.

Parameters:
[in] dev The output device to write the root into
See also:
MSDetectorFileOutput::writeXMLDetectorProlog
Exceptions:
IOError If an error on writing occurs (!!! not yet implemented)

Implements MSDetectorFileOutput.

Definition at line 298 of file MSE3Collector.cpp.

00298                                                                             {
00299     dev.writeXMLHeader("e3-detector");
00300 }

void MSE3Collector::writeXMLOutput ( OutputDevice &  dev,
SUMOTime  startTime,
SUMOTime  stopTime 
) throw (IOError) [virtual]

Writes collected values into the given stream.

Parameters:
[in] dev The output device to write the data into
[in] startTime First time step the data were gathered
[in] stopTime Last time step the data were gathered
See also:
MSDetectorFileOutput::writeXMLOutput
Exceptions:
IOError If an error on writing occurs (!!! not yet implemented)

Implements MSDetectorFileOutput.

Definition at line 231 of file MSE3Collector.cpp.

References MIN2(), myEnteredContainer, myID, myLastResetTime, myLeftContainer, SUMOReal, and time2string().

00232                                                                                     {
00233     dev<<"   <interval begin=\""<<time2string(startTime)<<"\" end=\""<<time2string(stopTime)<<"\" "<<"id=\""<<myID<<"\" ";
00234     // collect values about vehicles that have left the area
00235     unsigned vehicleSum = (unsigned) myLeftContainer.size();
00236     SUMOReal meanTravelTime = 0.;
00237     SUMOReal meanSpeed = 0.;
00238     SUMOReal meanHaltsPerVehicle = 0.;
00239     for (std::map<MSVehicle*, E3Values>::iterator i=myLeftContainer.begin(); i!=myLeftContainer.end(); ++i) {
00240         meanHaltsPerVehicle += (SUMOReal)(*i).second.haltings;
00241         SUMOReal steps = (*i).second.leaveTime-(*i).second.entryTime;
00242         meanTravelTime += steps;
00243         meanSpeed += ((*i).second.speedSum / steps);
00244     }
00245     meanTravelTime = vehicleSum!=0 ? meanTravelTime / (SUMOReal) vehicleSum : -1;
00246     meanSpeed = vehicleSum!=0 ?  meanSpeed / (SUMOReal) vehicleSum : -1;
00247     meanHaltsPerVehicle = vehicleSum!=0 ? meanHaltsPerVehicle / (SUMOReal) vehicleSum : -1;
00248     // clear container
00249     myLeftContainer.clear();
00250 
00251     // collect values about vehicles within the container
00252     unsigned vehicleSumWithin = (unsigned) myEnteredContainer.size();
00253     SUMOReal meanSpeedWithin = 0.;
00254     SUMOReal meanDurationWithin = 0.;
00255     SUMOReal meanHaltsPerVehicleWithin = 0.;
00256     SUMOReal meanIntervalSpeedWithin = 0.;
00257     SUMOReal meanIntervalHaltsPerVehicleWithin = 0.;
00258     SUMOReal meanIntervalDurationWithin = 0.;
00259     for (std::map<MSVehicle*, E3Values>::iterator i=myEnteredContainer.begin(); i!=myEnteredContainer.end(); ++i) {
00260         meanHaltsPerVehicleWithin += (SUMOReal)(*i).second.haltings;
00261         meanIntervalHaltsPerVehicleWithin += (SUMOReal)(*i).second.intervalHaltings;
00262         SUMOReal time = (SUMOReal)stopTime/1000. - (*i).second.entryTime;
00263         SUMOReal intLength = (SUMOReal)(stopTime - startTime) / 1000.;
00264         SUMOReal timeWithin = MIN2(time, intLength);
00265         meanSpeedWithin += ((*i).second.speedSum / time);
00266         meanIntervalSpeedWithin += ((*i).second.intervalSpeedSum / timeWithin);
00267         meanDurationWithin += time;
00268         meanIntervalDurationWithin += timeWithin;
00269         // reset interval values
00270         (*i).second.intervalHaltings = 0;
00271         (*i).second.intervalSpeedSum = 0;
00272     }
00273     myLastResetTime = stopTime;
00274     meanSpeedWithin = vehicleSumWithin!=0 ?  meanSpeedWithin / (SUMOReal) vehicleSumWithin : -1;
00275     meanHaltsPerVehicleWithin = vehicleSumWithin!=0 ? meanHaltsPerVehicleWithin / (SUMOReal) vehicleSumWithin : -1;
00276     meanDurationWithin = vehicleSumWithin!=0 ? meanDurationWithin / (SUMOReal) vehicleSumWithin : -1;
00277     meanIntervalSpeedWithin = vehicleSumWithin!=0 ?  meanIntervalSpeedWithin / (SUMOReal) vehicleSumWithin : -1;
00278     meanIntervalHaltsPerVehicleWithin = vehicleSumWithin!=0 ? meanIntervalHaltsPerVehicleWithin / (SUMOReal) vehicleSumWithin : -1;
00279     meanIntervalDurationWithin = vehicleSumWithin!=0 ? meanIntervalDurationWithin / (SUMOReal) vehicleSumWithin : -1;
00280 
00281     // write values
00282     dev<<"meanTravelTime=\""<<meanTravelTime
00283     <<"\" meanSpeed=\""<<meanSpeed
00284     <<"\" meanHaltsPerVehicle=\""<<meanHaltsPerVehicle
00285     <<"\" vehicleSum=\""<<vehicleSum
00286     <<"\" meanSpeedWithin=\""<<meanSpeedWithin
00287     <<"\" meanHaltsPerVehicleWithin=\""<<meanHaltsPerVehicleWithin
00288     <<"\" meanDurationWithin=\""<<meanDurationWithin
00289     <<"\" vehicleSumWithin=\""<<vehicleSumWithin
00290     <<"\" meanIntervalSpeedWithin=\""<<meanIntervalSpeedWithin
00291     <<"\" meanIntervalHaltsPerVehicleWithin=\""<<meanIntervalHaltsPerVehicleWithin
00292     <<"\" meanIntervalDurationWithin=\""<<meanIntervalDurationWithin
00293     <<"\"/>\n";
00294 }

Field Documentation

SUMOReal MSE3Collector::myCurrentHaltingsNumber [protected]

The current number of haltings (inside).

Definition at line 401 of file MSE3Collector.h.

Referenced by getCurrentHaltingNumber(), and update().

SUMOReal MSE3Collector::myCurrentMeanSpeed [protected]

The current mean speed of known vehicles (inside).

Definition at line 398 of file MSE3Collector.h.

Referenced by update().

SUMOReal MSE3Collector::myCurrentTouchedVehicles [protected]

The current number of vehicles inside;.

Please note, that vehicles that enter the area are given as a fraction

See also:
execute

Definition at line 408 of file MSE3Collector.h.

Referenced by update().

std::map<MSVehicle*, E3Values> MSE3Collector::myEnteredContainer [protected]

Container for vehicles that have entered the area.

Definition at line 388 of file MSE3Collector.h.

Referenced by enter(), getCurrentMeanSpeed(), getCurrentVehicleIDs(), getVehiclesWithin(), leave(), removeOnTripEnd(), update(), writeXMLOutput(), and ~MSE3Collector().

CrossSectionVector MSE3Collector::myEntries [protected]

The detector's entries.

Definition at line 342 of file MSE3Collector.h.

Referenced by GUIE3Collector::getEntries().

std::vector<MSE3EntryReminder*> MSE3Collector::myEntryReminders [protected]

The detector's built entry reminder.

Definition at line 348 of file MSE3Collector.h.

Referenced by MSE3Collector(), and ~MSE3Collector().

CrossSectionVector MSE3Collector::myExits [protected]

The detector's exits.

Definition at line 345 of file MSE3Collector.h.

Referenced by GUIE3Collector::getExits().

MetersPerSecond MSE3Collector::myHaltingSpeedThreshold [protected]

Speed-threshold to determine if a vehicle is halting.

Definition at line 358 of file MSE3Collector.h.

Referenced by enter(), leave(), and update().

SUMOTime MSE3Collector::myHaltingTimeThreshold [protected]

Definition at line 355 of file MSE3Collector.h.

Referenced by enter(), leave(), and update().

std::string MSE3Collector::myID [protected]

The detector's id.

Definition at line 339 of file MSE3Collector.h.

Referenced by getID(), and writeXMLOutput().

SUMOTime MSE3Collector::myLastResetTime [protected]

Information when the last reset has been done.

Definition at line 413 of file MSE3Collector.h.

Referenced by writeXMLOutput().

std::vector<MSE3LeaveReminder*> MSE3Collector::myLeaveReminders [protected]

The detector's built exit reminder.

Definition at line 351 of file MSE3Collector.h.

Referenced by MSE3Collector(), and ~MSE3Collector().

std::map<MSVehicle*, E3Values> MSE3Collector::myLeftContainer [protected]

Container for vehicles that have left the area.

Definition at line 391 of file MSE3Collector.h.

Referenced by leave(), reset(), and writeXMLOutput().

The documentation for this class was generated from the following files:
Generated on Wed May 5 00:06:47 2010 for Sumo - Simulation of Urban MObility by  doxygen 1.5.6