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 single_pararun(one_slice, *args):
# function to be used with optimize brute
inData, params, search_space = args # read static input
_inData = inData.copy()
_params = params.copy()
stamp = dict()
# parameterize
for i, key in enumerate(search_space.keys()):
val = search_space[key][int(one_slice[int(i)])]
stamp[key] = val
_params[key] = val
stamp['dt'] = str(pd.Timestamp.now()).replace('-','').replace('.','').replace(' ','')
filename = ''
for key, value in stamp.items():
filename += '-{}_{}'.format(key, value)
filename = re.sub('[^-a-zA-Z0-9_.() ]+', '', filename)
_inData.passengers = initialize_df(_inData.passengers)
_inData.requests = initialize_df(_inData.requests)
_inData.vehicles = initialize_df(_inData.vehicles)
sim = simulate(inData=_inData, params=_params, logger_level=logging.WARNING)
sim.dump(dump_id=filename, path = _params.paths.get('dumps', None)) # store results
print(filename, pd.Timestamp.now(), 'end')
return 0
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_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_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 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()
def myinit(self, **kwargs):
# part of init that is repeated every run
self.update_decisions_and_params(**kwargs)
self.make_skims()
self.set_variabilities()
self.env = simpy.Environment() # simulation environment init
self.t0 = self.inData.requests.treq.min(
) # start at the first request time
self.t1 = 60 * 60 * (self.params.simTime + 2)
self.trips = list() # report of trips
self.rides = list() # report of rides
self.passengers = self.inData.passengers.copy()
self.requests = initialize_df(self.inData.requests) # init requests
self.reqQ = list() # queue of requests (traveller ids)
self.vehQ = list() # queue of idle vehicles (driver ids)
self.pax = dict() # list of passengers
self.vehs = dict() # list of vehicles
self.plats = dict() # list of platforms
self.sim_start = None
