def test_configIO(self):
from MaaSSim.utils import make_config_paths
from MaaSSim.utils import get_config, save_config
CONFIG_PATH = os.path.join(os.path.dirname(__file__), 'config_utils_test.json')
params = get_config(CONFIG_PATH, root_path=os.path.dirname(__file__)) # load from .json file
params = make_config_paths(params, main='test_path', rel=True)
self.assertEqual(params.paths.G[0:9], 'test_path')
params.testIO = '12'
save_config(params, os.path.join(os.path.dirname(__file__), 'configIO_test.json'))
params = get_config(os.path.join(os.path.dirname(__file__), 'configIO_test.json'),
root_path=os.path.dirname(__file__)) # load from .json file
self.assertEqual(params.testIO, params.testIO)
def test_early_ending_shift_and_losing_patience(self):
"""
test if platform batches the results properly at matching
"""
from MaaSSim.traveller import travellerEvent
from MaaSSim.driver import driverEvent
from MaaSSim.data_structures import structures as this_inData_early
from MaaSSim.simulators import simulate as simulator_early
from MaaSSim.utils import prep_supply_and_demand, get_config, load_G
CONFIG_PATH = os.path.join(os.path.dirname(__file__), 'config_results_test.json')
params = get_config(CONFIG_PATH, root_path=os.path.dirname(__file__)) # load from .json file
params.nP = 2
params.nV = 1
params.times.patience = 30
this_inData_early = load_G(this_inData_early, params) # load network graph
this_inData_early = prep_supply_and_demand(this_inData_early, params) # generate supply and demand
this_inData_early.vehicles.shift_end = [100] # vehicle ends early
sim = simulator_early(params=params, inData=this_inData_early, event_based=False)
self.assertIn(travellerEvent.LOSES_PATIENCE.name, sim.runs[0].trips.event.values) # one traveller lost patience
r = sim.runs[0].rides
self.assertLess(r[r.event == driverEvent.ENDS_SHIFT.name].t.squeeze(), sim.t1) # did he really end earlier
del sim
del params
def simulate_parallel(config="../data/config/parallel.json", inData=None, params=None, search_space=None, **kwargs):
if inData is None: # othwerwise we use what is passed
from MaaSSim.data_structures import structures
inData = structures.copy() # fresh data
if params is None:
params = get_config(config, root_path = kwargs.get('root_path')) # load from .json file
if len(inData.G) == 0: # only if no graph in input
inData = load_G(inData, params, stats=True) # download graph for the 'params.city' and calc the skim matrices
if len(inData.passengers) == 0: # only if no passengers in input
inData = generate_demand(inData, params, avg_speed=True)
if len(inData.vehicles) == 0: # only if no vehicles in input
inData.vehicles = generate_vehicles(inData, params.nV)
if len(inData.platforms) == 0: # only if no platforms in input
inData.platforms = initialize_df(inData.platforms)
inData.platforms.loc[0] = empty_series(inData.platforms)
inData.platforms.fare = [1]
inData.vehicles.platform = 0
inData.passengers.platforms = inData.passengers.apply(lambda x: [0], axis=1)
inData = prep_shared_rides(inData, params.shareability) # obligatory to prepare schedules
brute(func=single_pararun,
ranges=slice_space(search_space, replications=params.parallel.get("nReplications",1)),
args=(inData, params, search_space),
full_output=True,
finish=None,
workers=params.parallel.get('nThread',1))
def test_driver_out(self):
from MaaSSim.simulators import simulate as simulator_driver_out
from MaaSSim.utils import get_config
from MaaSSim.decisions import dummy_False
from MaaSSim.decisions import f_driver_out
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_platform_choices.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
params.times.patience = 600 # 1 hour of simulation
params.nP = 100 # reuqests (and passengers)
params.nV = 50 # vehicles
params.simTime = 4
params.nD = 1
sim = simulator_driver_out(params=params, f_driver_out=dummy_False)
self.assertEqual(
sim.res[0].veh_exp[sim.res[0].veh_exp.ENDS_SHIFT == 0].shape[0], 0)
del sim
params.nD = 2
from MaaSSim.simulators import simulate as simulator_driver_out_2
sim2 = simulator_driver_out_2(params=params, f_driver_out=f_driver_out)
self.assertGreater(
sim2.res[1].veh_exp[sim2.res[1].veh_exp.ENDS_SHIFT == 0].shape[0],
0) # did someone
# end shift at beginning of simulation?
del sim2
del params
def test_staticIO(self):
"""
test if simulation can be restarted from static .csv file and yield the same results
"""
from MaaSSim.utils import prep_supply_and_demand, get_config, load_G
from MaaSSim.simulators import simulate as this_simulator
from MaaSSim.data_structures import structures as inData
from MaaSSim.utils import read_requests_csv, read_vehicle_positions
from pandas.testing import assert_frame_equal
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_results_test.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
inData = load_G(inData, params) # load network graph
inData = prep_supply_and_demand(inData,
params) # generate supply and demand
inData.requests.to_csv('requests.csv')
inData.vehicles.to_csv('vehicles.csv')
sim1 = this_simulator(params=params, inData=inData) # simulate
inData = read_requests_csv(inData, path='requests.csv')
inData = read_vehicle_positions(inData, path='vehicles.csv')
sim2 = this_simulator(params=params, inData=inData) # simulate
assert_frame_equal(sim2.runs[0].trips, sim2.runs[0].trips)
assert_frame_equal(sim2.runs[0].rides, sim2.runs[0].rides)
# self.assertTrue(sim2.runs[0].rides.equals(sim1.runs[0].rides))
del sim2
del sim1
def test_parallel(self):
"""
running parallel experiments on the multidimensional search space
"""
from dotmap import DotMap
from MaaSSim.utils import collect_results
from MaaSSim.utils import get_config
from MaaSSim.simulators import simulate_parallel as this_parallel_simulator
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_parallel_test.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
search_space = DotMap()
search_space.nP = [20, 40]
search_space.nV = [20, 40]
this_parallel_simulator(config=CONFIG_PATH,
search_space=search_space,
root_path=os.path.dirname(__file__))
res = collect_results(
params.paths.dumps
) # collect the results from multiple experiments
self.assertNotEqual(res.rides.t.mean(), res.rides.t.std())
self.assertNotEqual(res.trips.t.mean(), res.trips.t.std())
def test_platform_competition(self):
# make sure when you compete with the prcie, lowering the fare and increasing the fee
from MaaSSim.data_structures import structures as local_inData
from MaaSSim.decisions import f_platform_choice
from MaaSSim.simulators import simulate as platform_simulator_1
from MaaSSim.utils import get_config, generate_vehicles, generate_demand, initialize_df, load_G
CONFIG_PATH = os.path.join(os.path.dirname(__file__), 'config_platform_choices.json')
params = get_config(CONFIG_PATH, root_path=os.path.dirname(__file__)) # load from .json file
params.nP = 200 # reuqests (and passengers)
params.simTime = 4
params.nD = 1
fare = 1.5
fleet = 10
params.nV = 20 + fleet
inData = local_inData.copy()
inData = load_G(inData, params,
stats=True) # download graph for the 'params.city' and calc the skim matrices
inData = generate_demand(inData, params, avg_speed=True)
inData.vehicles = generate_vehicles(inData, params.nV)
inData.platforms = initialize_df(inData.platforms)
inData.platforms.loc[0] = [1, 'Platform1', 30]
inData.platforms.loc[1] = [fare, 'Platform2', 30]
inData = generate_demand(inData, params, avg_speed=True)
inData.vehicles = generate_vehicles(inData, params.nV)
inData.vehicles.platform = [0] * 20 + [1] * fleet
inData.passengers.platforms = inData.passengers.apply(lambda x: [0, 1], axis=1)
sim = platform_simulator_1(params=params, inData=inData, f_platform_choice=f_platform_choice)
ret = sim.res[0].veh_exp.copy()
ret['platform'] = inData.vehicles.platform
first = ret[ret.platform == 1].ARRIVES_AT_DROPOFF.sum()
fare = 0.5
fleet = 50
params.nV = 20 + fleet
inData = generate_demand(inData, params, avg_speed=True)
inData.vehicles = generate_vehicles(inData, params.nV)
inData.platforms = initialize_df(inData.platforms)
inData.platforms.loc[0] = [1, 'Platform1', 30]
inData.platforms.loc[1] = [fare, 'Platform2', 30]
inData = generate_demand(inData, params, avg_speed=True)
inData.vehicles = generate_vehicles(inData, params.nV)
inData.vehicles.platform = [0] * 20 + [1] * fleet
inData.passengers.platforms = inData.passengers.apply(lambda x: [0, 1], axis=1)
from MaaSSim.simulators import simulate as platform_simulator_2
sim2 = platform_simulator_2(params=params, inData=inData, f_platform_choice=f_platform_choice)
ret = sim2.res[0].veh_exp
ret['platform'] = inData.vehicles.platform
second = ret[ret.platform == 1].ARRIVES_AT_DROPOFF.sum()
self.assertGreater(second, first)
del sim
del sim2
del params
del inData
def test_batch_platform(self):
"""
test if platform batches the results properly at matching
"""
from MaaSSim.utils import initialize_df, get_config, load_G, prep_supply_and_demand
from MaaSSim.data_structures import structures as inData
from MaaSSim.simulators import simulate as this_simulator
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_results_test.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
inData = load_G(inData, params) # load network graph
inData = prep_supply_and_demand(inData,
params) # generate supply and demand
inData.platforms = initialize_df(inData.platforms)
inData.platforms.loc[0] = [1, 'Uber',
600] # batch requests every 600 seconds
sim = this_simulator(params=params, inData=inData, event_based=False)
Qs = sim.runs[0].queues
Qs.groupby('platform')[['vehQ', 'reqQ']].plot(drawstyle='steps-post')
r = sim.runs[0].trips
times = r[r.event == 'RECEIVES_OFFER'].t.sort_values(
ascending=True).diff().dropna().unique()
self.assertIn(600, times) # are requests batched ony at batch_time
del sim
del params
del inData
def test_driver_repositioning(self):
from MaaSSim.simulators import simulate as repos_simulator
from MaaSSim.driver import driverEvent
from MaaSSim.decisions import f_repos
from MaaSSim.utils import get_config
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_platform_choices.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
params.times.patience = 600 # 1 hour of simulation
params.nP = 100 # reuqests (and passengers)
params.nV = 50 # vehicles
params.simTime = 4
params.nD = 1
sim1 = repos_simulator(params=params)
self.assertNotIn(driverEvent.STARTS_REPOSITIONING.name,
sim1.runs[0].rides.event.values) # no rejections
del sim1
sim2 = repos_simulator(params=params, f_driver_repos=f_repos)
self.assertIn(driverEvent.STARTS_REPOSITIONING.name,
sim2.runs[0].rides.event.values) # no rejections
del sim2
del params
def test_maassim_with_exmas(self):
from MaaSSim.data_structures import structures as inData
from MaaSSim.utils import get_config, load_G, prep_supply_and_demand, generate_demand, generate_vehicles, \
initialize_df # simulator
from MaaSSim.simulators import simulate
from MaaSSim.driver import driverEvent
from MaaSSim.utils import get_config
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_platform_choices.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
params.times.pickup_patience = 3600 # 1 hour of simulation
params.simTime = 4 # 1 hour of simulation
params.nP = 500 # reuqests (and passengers)
params.nV = 100 # vehicles
params.shareability.avg_speed = params.speeds.ride
params.shareability.shared_discount = 0.3
params.shareability.delay_value = 1
params.shareability.WtS = 1.3
params.shareability.price = 1.5 # eur/km
params.shareability.VoT = 0.0035 # eur/s
params.shareability.matching_obj = 'u_pax' # minimize VHT for vehicles
params.shareability.pax_delay = 0
params.shareability.horizon = 600
params.shareability.max_degree = 4
params.shareability.nP = params.nP
params.shareability.share = 1
params.shareability.without_matching = True
inData = load_G(inData, params) # load network graph
inData = generate_demand(inData, params, avg_speed=False)
inData.vehicles = generate_vehicles(inData, params.nV)
inData.vehicles.platform = inData.vehicles.apply(lambda x: 0, axis=1)
inData.passengers.platforms = inData.passengers.apply(lambda x: [0],
axis=1)
inData.requests['platform'] = inData.requests.apply(
lambda row: inData.passengers.loc[row.name].platforms[0], axis=1)
inData.platforms = initialize_df(inData.platforms)
inData.platforms.loc[0] = [1, 'Uber', 30]
params.shareability.share = 1
params.shareability.without_matching = True
inData = ExMAS.main(inData, params.shareability,
plot=False) # create shareability graph (ExMAS)
sim = simulate(params=params, inData=inData) # simulate
self.assertGreater(sim.inData.sblts.schedule.kind.max(),
10) # are there shared rides in the solution
self.assertGreater(
sim.runs[0].rides.paxes.apply(lambda x: len(x)).max(),
1) # did someone travel together
def simulate(config="../data/config/default.json",
inData=None,
params=None,
**kwargs):
"""
main runner and wrapper
loads or uses json config to prepare the data for simulation, run it and process the results
:param config: .json file path
:param inData: optional input data
:param params: loaded json file
:param kwargs: optional arguments
:return: simulation object with results
"""
if inData is None: # otherwise we use what is passed
from MaaSSim.data_structures import structures
inData = structures.copy() # fresh data
if params is None:
params = get_config(
config, root_path=kwargs.get('root_path')) # load from .json file
if kwargs.get('make_main_path', False):
from MaaSSim.utils import make_config_paths
params = make_config_paths(params,
main=kwargs.get('make_main_path', False),
rel=True)
if params.paths.get('requests', False):
inData = read_requests_csv(inData, path=params.paths.requests)
if params.paths.get('vehicles', False):
inData = read_vehicle_positions(inData, path=params.paths.vehicles)
if len(inData.G) == 0: # only if no graph in input
inData = load_G(
inData, params, stats=True
) # download graph for the 'params.city' and calc the skim matrices
if len(inData.passengers) == 0: # only if no passengers in input
inData = generate_demand(inData, params, avg_speed=True)
if len(inData.vehicles) == 0: # only if no vehicles in input
inData.vehicles = generate_vehicles(inData, params.nV)
if len(inData.platforms) == 0: # only if no platforms in input
inData.platforms = initialize_df(inData.platforms)
inData.platforms.loc[0] = empty_series(inData.platforms)
inData.platforms.fare = [1]
inData = prep_shared_rides(inData,
params.shareability) # prepare schedules
sim = Simulator(inData, params=params, **kwargs) # initialize
for day in range(params.get('nD', 1)): # run iterations
sim.make_and_run(run_id=day) # prepare and SIM
sim.output() # calc results
if sim.functions.f_stop_crit(sim=sim):
break
return sim
def platforms():
# play the market competition scenarios. You compete with platform of 20 vehs in fleet and charging 1/km.
# You explore how to compete varying fleet from 5 to 40 vehicles and price ranges from .6 to 1.4
# experiments are run sequentially and collect to ine csv
# (error prone and using single thread, only for small experiments)
print(os.getcwd())
def experiment(inData, params, fare=0.8, fleet=20):
params.nV = 20 + fleet # vehicles
inData = generate_demand(inData, params, avg_speed=True)
inData.vehicles = generate_vehicles(inData, params.nV)
inData.platforms = initialize_df(inData.platforms)
inData.platforms.loc[0] = [1, 'Platform1', 30]
inData.platforms.loc[1] = [fare, 'Platform2', 30]
inData = generate_demand(inData, params, avg_speed=True)
inData.vehicles = generate_vehicles(inData, params.nV)
inData.vehicles.platform = [0] * 20 + [1] * fleet
# inData.vehicles.platform = inData.vehicles.apply(lambda x: 1 if random.random()<0.5 else 0, axis = 1) # randomly 30% vehicles for first platform, 70% for 2nd
inData.passengers.platforms = inData.passengers.apply(lambda x: [0, 1], axis=1)
sim = simulate(params=params, inData=inData, print=False, f_platform_choice=f_platform_choice,
logger_level=logging.CRITICAL)
ret = sim.res[0].veh_exp
ret['platform'] = inData.vehicles.platform
return ret[ret.platform == 1].ARRIVES_AT_DROPOFF.sum()
from MaaSSim.data_structures import structures as inData
params = get_config('../../data/config/platforms.json') # load configuration
params.paths.G = '../../data/graphs/delft.graphml'
params.paths.skim = '../../data/graphs/delft.csv'
inData = load_G(inData, params) # load network graph
params.nP = 200 # reuqests (and passengers)
params.simTime = 4
params.nD = 1
ret = []
for repl in range(10):
for fleet in [5, 10, 15, 20, 25, 30, 40]:
for fare in [0.6, 0.8, 1, 1.2, 1.4]:
revenue = experiment(inData, params, fare=fare, fleet=fleet)
print(fleet, fare, revenue, repl)
ret.append({'fleet': fleet, 'fare': fare, 'revenue': revenue, 'repl': repl})
pd.DataFrame(ret).to_csv('pricing.csv')
def test_prep(self):
"""
tests if simulation is prepared properly (reuests, passengers, vehicles are generated)
"""
from MaaSSim.utils import prep_supply_and_demand, get_config, load_G
from MaaSSim.data_structures import structures as inData
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_results_test.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
inData = load_G(inData, params) # load network graph
inData = prep_supply_and_demand(inData,
params) # generate supply and demand
self.assertEqual(inData.requests.shape[0], params.nP)
self.assertEqual(inData.passengers.shape[0], params.nP)
self.assertEqual(inData.vehicles.shape[0], params.nV)
def test_driver_decline(self):
from MaaSSim.simulators import simulate as simulator_driver_decl
from MaaSSim.traveller import travellerEvent
from MaaSSim.utils import get_config
from MaaSSim.decisions import dummy_False
from MaaSSim.decisions import f_decline
CONFIG_PATH = os.path.join(os.path.dirname(__file__), 'config_platform_choices.json')
params = get_config(CONFIG_PATH, root_path=os.path.dirname(__file__)) # load from .json file
params.times.patience = 600 # 1 hour of simulation
params.nP = 10 # reuqests (and passengers)
params.nV = 10 # vehicles
params.simTime = 4
params.nD = 1
sim = simulator_driver_decl(params=params, f_driver_decline=f_decline)
del sim
del params
def test_multiple_days(self):
# have two runs in the same instance and see if they are different
from MaaSSim.data_structures import structures as my_inData
from MaaSSim.decisions import f_platform_choice
from MaaSSim.simulators import simulate as multiple_days_simulator
from MaaSSim.utils import get_config, generate_vehicles, generate_demand, initialize_df, load_G
from MaaSSim.simulators import simulate as simulator_for_multiple_days
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_results_test.json')
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
params.times.patience = 3600 # 1 hour of simulation
params.simTime = 1 # 1 hour of simulation
params.nP = 30 # reuqests (and passengers)
params.nV = 30 # vehicles
params.nD = 3
inData = my_inData.copy()
inData = load_G(
inData, params, stats=True
) # download graph for the 'params.city' and calc the skim matrices
inData = generate_demand(inData, params, avg_speed=True)
inData.vehicles = generate_vehicles(inData, params.nV)
sim = multiple_days_simulator(params=params,
inData=inData,
print=False,
f_platform_choice=f_platform_choice)
self.assertEqual(len(sim.runs), 3)
del sim
del params
def supply_demand():
# explore various supply and demand setting with parallel simulations replicatrd 10 times,
# each stored to separate .zip file (to be further merged with collect_results from utils)
from MaaSSim.data_structures import structures as inData
params = get_config('../../data/config/delft.json') # load configuration
params.paths.dumps = '../docs/experiments/sd'
params.times.patience = 1200
params.simTime = 4
params.parallel.nThread = 4
params.parallel.nReplications = 10
params.paths.G = '../../data/graphs/delft.graphml'
params.paths.skim = '../../data/graphs/delft.csv'
inData = load_G(inData, params) # load network graph
space = DotMap()
space.nP = list(range(50,1001,50))
space.nV = list(range(20,201,20))
print(dict(space))
simulate_parallel(params = params, search_space = space)
def test_networkIO(self):
from numpy import inf
from MaaSSim.utils import load_G, download_G, save_G, get_config
from MaaSSim.data_structures import structures as inData
CONFIG_PATH = os.path.join(os.path.dirname(__file__), 'config_utils_test.json')
params = get_config(CONFIG_PATH, root_path=os.path.dirname(__file__)) # load from .json file
params.city = 'Wieliczka, Poland'
params.paths.G = os.path.join(os.path.dirname(__file__),
params.city.split(",")[0] + ".graphml") # graphml of a current .city
params.paths.skim = os.path.join(os.path.dirname(__file__), params.city.split(",")[
0] + ".csv") # csv with a skim between the nodes of the .city
inData = download_G(inData, params) # download the graph and compute the skim
save_G(inData, params) # save it to params.paths.G
inData = load_G(inData, params,
stats=True) # download graph for the 'params.city' and calc the skim matrices
self.assertGreater(inData.nodes.shape[0], 10) # do we have nodes
self.assertGreater(inData.skim.shape[0], 10) # do we have skim
self.assertLess(inData.skim.mean().mean(), inf) # and values inside
self.assertGreater(inData.skim.mean().mean(), 0) # positive distances
def test_rejects(self):
# make sure that rejection works for drivers and travellers (dummy reject with fixed probability)
from MaaSSim.utils import get_config
from MaaSSim.decisions import dummy_False
from MaaSSim.traveller import travellerEvent
from MaaSSim.driver import driverEvent
from MaaSSim.data_structures import structures as this_inData
from MaaSSim.simulators import simulate as reject_simulator
CONFIG_PATH = os.path.join(os.path.dirname(__file__),
'config_platform_choices.json')
def rand_reject8(**kwargs):
# sample function to reject with probability of 50%
return random.random() >= 0.8
params = get_config(
CONFIG_PATH,
root_path=os.path.dirname(__file__)) # load from .json file
params.times.patience = 3600 # 1 hour of simulation
params.simTime = 1 # 1 hour of simulation
params.nP = 100 # reuqests (and passengers)
params.nV = 100 # vehicles
# A no rejections
sim = reject_simulator(params=params,
inData=this_inData.copy(),
f_trav_mode=dummy_False,
f_driver_decline=dummy_False)
self.assertNotIn(travellerEvent.IS_REJECTED_BY_VEHICLE.name,
sim.runs[0].trips.event.values) # no rejections
self.assertNotIn(travellerEvent.REJECTS_OFFER.name,
sim.runs[0].trips.event.values) # no rejections
self.assertNotIn(driverEvent.REJECTS_REQUEST.name,
sim.runs[0].rides.event.values) # no rejections
self.assertNotIn(driverEvent.IS_REJECTED_BY_TRAVELLER.name,
sim.runs[0].rides.event.values) # no rejections
# B vehicle rejects
del sim
from MaaSSim.simulators import simulate as reject_simulator2
sim = reject_simulator2(params=params,
inData=this_inData.copy(),
f_trav_mode=dummy_False,
f_driver_decline=rand_reject8,
f_platform_choice=dummy_False)
self.assertIn(travellerEvent.IS_REJECTED_BY_VEHICLE.name,
sim.runs[0].trips.event.values) # no rejections
self.assertNotIn(travellerEvent.REJECTS_OFFER.name,
sim.runs[0].trips.event.values) # no rejections
self.assertIn(driverEvent.REJECTS_REQUEST.name,
sim.runs[0].rides.event.values) # no rejections
self.assertNotIn(driverEvent.IS_REJECTED_BY_TRAVELLER.name,
sim.runs[0].rides.event.values) # no rejections
# # C traveller rejects
del sim
from MaaSSim.simulators import simulate as reject_simulator3
sim = reject_simulator3(params=params,
inData=this_inData.copy(),
f_trav_mode=rand_reject8,
f_driver_decline=dummy_False,
f_platform_choice=dummy_False)
self.assertNotIn(travellerEvent.IS_REJECTED_BY_VEHICLE.name,
sim.runs[0].trips.event.values) # no rejections
self.assertIn(travellerEvent.REJECTS_OFFER.name,
sim.runs[0].trips.event.values) # no rejections
self.assertNotIn(driverEvent.REJECTS_REQUEST.name,
sim.runs[0].rides.event.values) # no rejections
self.assertIn(driverEvent.IS_REJECTED_BY_TRAVELLER.name,
sim.runs[0].rides.event.values) # no rejections
#
# # D both reject
del sim
from MaaSSim.simulators import simulate as reject_simulator4
sim = reject_simulator4(params=params,
inData=this_inData.copy(),
f_trav_mode=rand_reject8,
f_driver_decline=rand_reject8,
f_platform_choice=dummy_False)
self.assertIn(travellerEvent.IS_REJECTED_BY_VEHICLE.name,
sim.runs[0].trips.event.values) # no rejections
self.assertIn(travellerEvent.REJECTS_OFFER.name,
sim.runs[0].trips.event.values) # no rejections
self.assertIn(driverEvent.REJECTS_REQUEST.name,
sim.runs[0].rides.event.values) # no rejections
self.assertIn(driverEvent.IS_REJECTED_BY_TRAVELLER.name,
sim.runs[0].rides.event.values) # no rejections
del sim
