Adding fares functionality

README.md

@@ -143,7 +143,7 @@ There are three places where fares factor into the fast-trips.
 
 1. During path-finding (C++ extension), fares get assessed as a cost onto links, which translate to generalized cost (minutes) via the traveler's value of time.  Transfer fare rules here are complicated, because we don't know which is the next/previous fare, and we can only guess based on probabilities.  The fare is estimated using [`Hyperlink::getFareWithTransfer()`](src/hyperlink.cpp).  Turn this off using configuration option `transfer_fare_ignore`.
 2. During path-enumeration (C++ extension), when the paths are being constructed by choosing links from the hyperpath graph, at the point where each link is added to the path, the fare *could be* adjusted with more certainty of the the path so far.  This is currently not being done but it would be in [`Path::addLink()`](src/path.cpp) and/or [`Hyperlink::setupProbabilities()`](src/hyperlink.cpp).  It may be valuable since it may affect the probability of the next link being chosen since the fare could be set with more certainty and then the potential link costs could be updated along with their pboabilities.
-3. During path-enumeration (C++ extension), after the path is constructed, the trip cost is re-calculated at the end using [`Path::calculateCost()`](src/path.cpp).  At this moment in the process, the path is complete and final, so the fare transfer rules are certain.
+3. During path-enumeration (C++ extension), after the path is constructed, the trip cost is re-calculated at the end using [`Path::calculateCost()`](src/path.cpp).  At this moment in the process, the path is complete and final, so the fare transfer rules are certain.  The initial fare and cost are saved and passed back to python to show the effect of step 1.
 4. During simulation (python), while the path is being adjusted due to vehicle times, the fares are calculated via [`Route.add_fares()`](fasttrips/Route.py).  This is unlikely to change anything unless the fare periods changed due to the slow-down of vehicles -- so consider deprecating this in favor of using the pathfinding results?  For now, it's a good test that the C++ code is working as expected; running with simulation off should result in identical fare and cost results from pathfinding and the (non-vehicle-updating) python simulation.
 
 ## Test Sample Input

fasttrips/Assignment.py

@@ -922,7 +922,10 @@ def find_trip_based_pathset(iteration, pathset, hyperpath, trace):
 
             pathdict[path_num] = {}
             pathdict[path_num][PathSet.PATH_KEY_COST       ] = path_costs[path_num, 0]
-            pathdict[path_num][PathSet.PATH_KEY_PROBABILITY] = path_costs[path_num, 1]
+            pathdict[path_num][PathSet.PATH_KEY_FARE       ] = path_costs[path_num, 1]
+            pathdict[path_num][PathSet.PATH_KEY_PROBABILITY] = path_costs[path_num, 2]
+            pathdict[path_num][PathSet.PATH_KEY_INIT_COST  ] = path_costs[path_num, 3]
+            pathdict[path_num][PathSet.PATH_KEY_INIT_FARE  ] = path_costs[path_num, 4]
             # List of (stop_id, stop_state)
             pathdict[path_num][PathSet.PATH_KEY_STATES     ] = []
 

fasttrips/Passenger.py

@@ -509,7 +509,10 @@ def setup_passenger_pathsets(self, iteration, stops, trip_id_df, trips_df, modes
         `pf_iteration`                int64  iteration in which these paths were found
         `pathnum`                     int64  the path number for the path within the pathset
         `pf_cost`                   float64  the cost of the entire path
+        `pf_fare`                   float64  the fare of the entire path
         `pf_probability`            float64  the probability of the path
+        `pf_initcost`               float64  the initial cost of the entire path
+        `pf_initfare`               float64  the initial fare of the entire path
         `description`                object  string representation of the path
         ==================  ===============  =====================================================================================================
 
@@ -608,7 +611,10 @@ def setup_passenger_pathsets(self, iteration, stops, trip_id_df, trips_df, modes
                     iteration,
                     pathnum,
                     pathset.pathdict[pathnum][PathSet.PATH_KEY_COST],
-                    pathset.pathdict[pathnum][PathSet.PATH_KEY_PROBABILITY]
+                    pathset.pathdict[pathnum][PathSet.PATH_KEY_FARE],
+                    pathset.pathdict[pathnum][PathSet.PATH_KEY_PROBABILITY],
+                    pathset.pathdict[pathnum][PathSet.PATH_KEY_INIT_COST],
+                    pathset.pathdict[pathnum][PathSet.PATH_KEY_INIT_FARE]
                 ])
 
                 link_num   = 0
@@ -689,7 +695,10 @@ def setup_passenger_pathsets(self, iteration, stops, trip_id_df, trips_df, modes
             Passenger.PF_COL_PF_ITERATION,
             Passenger.PF_COL_PATH_NUM,
             PathSet.PATH_KEY_COST,
-            PathSet.PATH_KEY_PROBABILITY ])
+            PathSet.PATH_KEY_FARE,
+            PathSet.PATH_KEY_PROBABILITY,
+            PathSet.PATH_KEY_INIT_COST,
+            PathSet.PATH_KEY_INIT_FARE])
 
         pathset_links_df = pandas.DataFrame(linklist, columns=[\
             Passenger.TRIP_LIST_COLUMN_PERSON_ID,

fasttrips/PathSet.py

@@ -100,8 +100,11 @@ class PathSet:
     DIR_OUTBOUND    = 1  #: Trips outbound from home have preferred arrival times
     DIR_INBOUND     = 2  #: Trips inbound to home have preferred departure times
 
-    PATH_KEY_COST           = "pf_cost"
-    PATH_KEY_PROBABILITY    = "pf_probability"
+    PATH_KEY_COST           = "pf_cost"         #: path cost according to pathfinder
+    PATH_KEY_FARE           = "pf_fare"         #: path fare according to pathfinder
+    PATH_KEY_PROBABILITY    = "pf_probability"  #: path probability according to pathfinder
+    PATH_KEY_INIT_COST      = "pf_initcost"     #: initial cost (in pathfinding, before path was finalized)
+    PATH_KEY_INIT_FARE      = "pf_initfare"     #: initial fare (in pathfinding, before path was finalized)
     PATH_KEY_STATES         = "states"
 
     STATE_IDX_LABEL         = 0  #: :py:class:`datetime.timedelta` instance

fasttrips/Util.py

@@ -53,7 +53,7 @@ class Util:
     ]
     DROP_PATHFINDING_COLUMNS = [
         # pathfinding debugging
-        "pf_iteration","pf_A_time","pf_B_time","pf_linktime","pf_linkcost","pf_linkdist","pf_waittime","pf_linkfare"
+        "pf_iteration","pf_A_time","pf_B_time","pf_linktime","pf_linkcost","pf_linkdist","pf_waittime","pf_linkfare","pf_cost","pf_fare","pf_initcost","pf_initfare"
     ]
 
     @staticmethod

src/fasttrips.cpp

@@ -142,10 +142,10 @@ _fasttrips_find_pathset(PyObject *self, PyObject *args)
     dims_double[1] = 8; // label_, deparr_time_, link_time_, link_cost_, link_dist_, cost_, arrdep_time_
     PyArrayObject *ret_double = (PyArrayObject *)PyArray_SimpleNew(2, dims_double, NPY_DOUBLE);
 
-    // costs and probability
+    // cost, fare, probability, initial cost, initial fare
     npy_intp dims_paths[2];
     dims_paths[0] = pathset.size();
-    dims_paths[1] = 2;
+    dims_paths[1] = 5;
     PyArrayObject *ret_paths = (PyArrayObject*)PyArray_SimpleNew(2, dims_paths, NPY_DOUBLE);
 
     int ind      = 0;
@@ -154,7 +154,10 @@ _fasttrips_find_pathset(PyObject *self, PyObject *args)
         const fasttrips::Path& path = psi->first;
 
         *(npy_double*)PyArray_GETPTR2(ret_paths, path_num, 0) = path.cost();
-        *(npy_double*)PyArray_GETPTR2(ret_paths, path_num, 1) = psi->second.probability_;
+        *(npy_double*)PyArray_GETPTR2(ret_paths, path_num, 1) = path.fare();
+        *(npy_double*)PyArray_GETPTR2(ret_paths, path_num, 2) = psi->second.probability_;
+        *(npy_double*)PyArray_GETPTR2(ret_paths, path_num, 3) = path.initialCost();
+        *(npy_double*)PyArray_GETPTR2(ret_paths, path_num, 4) = path.initialFare();
 
         for (int link_num = 0; link_num < path.size(); ++link_num) {
             *(npy_int32*)PyArray_GETPTR2(ret_int, ind, 0) = path_num;

src/path.cpp

@@ -13,15 +13,21 @@ namespace fasttrips {
     Path::Path() :
         outbound_(false),
         enumerating_(false),
+        fare_(0),
         cost_(0),
-        capacity_problem_(false)
+        capacity_problem_(false),
+        initial_fare_(0),
+        initial_cost_(0)
     {}
 
     Path::Path(bool outbound, bool enumerating) :
         outbound_(outbound),
         enumerating_(enumerating),
+        fare_(0),
         cost_(0),
-        capacity_problem_(false)
+        capacity_problem_(false),
+        initial_fare_(0),
+        initial_cost_(0)
     {}
 
     Path::~Path()
@@ -33,12 +39,26 @@ namespace fasttrips {
         return links_.size();
     }
 
-    // What's the cost of this path?
     double Path::cost() const
     {
         return cost_;
     }
 
+    double Path::fare() const
+    {
+        return fare_;
+    }
+
+    double Path::initialCost() const
+    {
+        return initial_cost_;
+    }
+
+    double Path::initialFare() const
+    {
+        return initial_fare_;
+    }
+
     // Clear
     void Path::clear()
     {
@@ -120,7 +140,7 @@ namespace fasttrips {
                 trace_file << std::endl;
 
                 // delete this later
-                trace_file << "--------------- path_before ---- (cost " << cost_ << ")" << std::endl;
+                trace_file << "--------------- path_before ---- (cost " << cost_ << ", fare " << fare_ << ")" << std::endl;
                 print(trace_file, path_spec, pf);
                 trace_file << "--------------------------------" << std::endl;
             }
@@ -220,6 +240,7 @@ namespace fasttrips {
             }
         }
         cost_          += new_link.link_cost_;
+        fare_          += new_link.link_fare_;
         new_link.cost_  = cost_;
         links_.push_back( std::make_pair(stop_id, new_link) );
 
@@ -231,7 +252,7 @@ namespace fasttrips {
 
             // this is excessive but oh well
             if (links_.size() > 1) {
-                trace_file << "--------------- path so far ----" << (feasible ? " (feasible)" : " (infeasible)") << " (cost " << cost_ << ")" << std::endl;
+                trace_file << "--------------- path so far ----" << (feasible ? " (feasible)" : " (infeasible)") << " (cost " << cost_ << ", fare " << fare_ << ")" << std::endl;
                 print(trace_file, path_spec, pf);
                 trace_file << "--------------------------------" << std::endl;
             }
@@ -289,9 +310,14 @@ namespace fasttrips {
         // no stops - nothing to do
         if (links_.size()==0) { return; }
 
+        // save aside the fare and cost
+        initial_fare_ = fare_;
+        initial_cost_ = cost_;
+
         bool chrono_order   = (!outbound_ && !enumerating_) || (outbound_ && enumerating_);
         if (path_spec.trace_ && !hush) {
-            trace_file << "calculatePathCost: (chrono? " << (chrono_order ? "yes)" : "no)") << std::endl;
+            trace_file << "calculatePathCost: (chrono? " << (chrono_order ? "yes, " : "no,");
+            trace_file << " cost: " << initial_cost_ << ", fare: " << initial_fare_ << ")" << std::endl;
             print(trace_file, path_spec, pf);
             trace_file << std::endl;
         }
@@ -305,6 +331,7 @@ namespace fasttrips {
         int inc             = chrono_order ? 1 : -1;
 
         cost_               = 0;
+        fare_               = 0;
         std::string last_fare_period;
 
         // for free transfer calculations -- fare_period -> (first board time, board count)
@@ -412,11 +439,12 @@ namespace fasttrips {
                 first_trip = false;
             }
             cost_                            += stop_state.link_cost_;
+            fare_                            += stop_state.link_fare_;
             stop_state.cost_                  = cost_;
         }
 
         if (path_spec.trace_ && !hush) {
-            trace_file << " ==================================================> cost: " << cost_ << std::endl;
+            trace_file << " ==================================================> cost: " << cost_ << ", fare: " << fare_ << std::endl;
             print(trace_file, path_spec, pf);
             trace_file << std::endl;
         }

src/path.h

@@ -34,9 +34,18 @@ namespace fasttrips {
     private:
         bool    outbound_;          ///< is this path outbound (preferred arrival) or inbound (preferred departure)?
         bool    enumerating_;       ///< are we enumarating paths?  or labeling?
+        double  fare_;              ///< Total fare of this path.
         double  cost_;              ///< Cost of this path.
         bool    capacity_problem_;  ///< Does this path have a capacity problem?
 
+        /// For debugging/investigation.  When we first enumerate this path by adding links
+        /// via Path::addLink(), we're guessing at fares and costs.  When we finally complete the
+        /// path and call Path::calculateCost(), we will know cost and fare with full information.
+        /// These variables are for saving our initial understanding to see how far off we were.
+        /// These are set in calculateCost().
+        double initial_fare_;       ///< Initial total fare
+        double initial_cost_;       ///< Initial cost
+
         /// The links that make up this path (stop id, stop states)
         /// They are in origin to destination order for outbound trips,
         /// and destination to origin order for inbound trips.
@@ -52,9 +61,11 @@ namespace fasttrips {
 
         /// How many links are in this path?
         size_t size() const;
-        /// What's the cost of this path?
         double cost() const;
-        /// Clear
+        double fare() const;
+        double initialCost() const; ///< initial understanding of the cost before path was finalized
+        double initialFare() const; ///< initial understanding of the fare before path was finalized
+
         void clear();
 
         /// Accessors