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