def categorize(ttri, prd, ttdata, **kwargs): """ :type ttri: pyticas_tetres.ttypes.TTRouteInfo :type prd: pyticas.ttypes.Period :type ttdata: list[pyticas_tetres.ttypes.TravelTimeInfo] :return: """ lock = kwargs.get('lock', nonop_with()) given_seis = kwargs.get('specialevents', None) seis = given_seis or se_helper.find_specialevents( prd, SE_ARRIVAL_WINDOW, SE_DEPARTURE_WINDOW1, SE_DEPARTURE_WINDOW2) specialevents = [] for sei in seis: distance = loc.minimum_distance(ttri.route, float(sei.lat), float(sei.lon)) specialevents.append((sei, distance)) year = prd.start_date.year ttseDA = TTSpecialeventDataAccess(year) # avoid to save duplicated data with lock: is_deleted = ttseDA.delete_range(ttri.id, prd.start_date, prd.end_date, item_ids=[v.id for v in seis]) if not is_deleted or not ttseDA.commit(): ttseDA.rollback() ttseDA.close_session() getLogger(__name__).debug( '! specialevent.categorize(): fail to delete existing data') return -1 dict_data = [] for idx, tti in enumerate(ttdata): seis = _find_ses(specialevents, tti.str2datetime(tti.time)) for (sei, distance, event_type) in seis: dict_data.append({ 'tt_id': tti.id, 'specialevent_id': sei.id, 'distance': distance, 'event_type': event_type }) if dict_data: with lock: inserted_ids = ttseDA.bulk_insert(dict_data, print_exception=True) if not inserted_ids or not ttseDA.commit(): ttseDA.rollback() ttseDA.close_session() getLogger(__name__).warning( '! specialevent.categorize(): fail to insert categorized data' ) return -1 ttseDA.close_session() return len(dict_data)
def calculate_a_route(prd, ttri, **kwargs): """ :type prd: pyticas.ttypes.Period :type ttri: pyticas_tetres.ttypes.TTRouteInfo """ logger = getLogger(__name__) dbsession = kwargs.get('dbsession', None) if dbsession: da_tt = TravelTimeDataAccess(prd.start_date.year, session=dbsession) else: da_tt = TravelTimeDataAccess(prd.start_date.year) lock = kwargs.get('lock', nonop_with()) # delete data to avolid duplicated data with lock: is_deleted = da_tt.delete_range(ttri.id, prd.start_date, prd.end_date, print_exception=True) if not is_deleted or not da_tt.commit(): logger.warning('fail to delete the existing travel time data') if not dbsession: da_tt.close_session() return False # calculate tt and vmt (res_tt, res_speed, res_vmt) = _calculate_tt(ttri.route, prd) if res_tt is None: logger.warning('fail to calculate travel time') return False avg_speeds = _route_avgs(res_speed) total_vmts = _route_total(res_vmt) seg_tt = res_tt[-1].data timeline = prd.get_timeline(as_datetime=False, with_date=True) data = [] for idx, dts in enumerate(timeline): data.append({ 'route_id': ttri.id, 'time': dts, 'tt': seg_tt[idx], 'vmt': total_vmts[idx], 'speed': avg_speeds[idx] }) with lock: inserted_ids = da_tt.bulk_insert(data) if not inserted_ids or not da_tt.commit(): logger.warning('fail to insert the calculated travel time into database') if not dbsession: da_tt.close_session() return False if not dbsession: da_tt.close_session() return inserted_ids
def categorize(ttri, prd, ttdata, **kwargs): """ :type ttri: pyticas_tetres.ttypes.TTRouteInfo :type prd: pyticas.ttypes.Period :type ttdata: list[pyticas_tetres.ttypes.TravelTimeInfo] :rtype: int """ lock = kwargs.get('lock', nonop_with()) given_incidents = kwargs.get('incidents', None) all_incidents = given_incidents or ihelper.find_incidents(ttri.corridors()[0], prd) route_length = ttri.route.length() incd_locations = [] for incd in all_incidents: distance = loc.location_by_coordinate(ttri.route, incd.lat, incd.lon) if distance != False: if distance < -INCIDENT_UPSTREAM_DISTANCE_LIMIT or distance > route_length + INCIDENT_DOWNSTREAM_DISTANCE_LIMIT: continue off_distance = distance if distance < 0 else max(0, distance - route_length) incd_locations.append((distance, off_distance, incd)) year = prd.start_date.year ttincident_da = TTIncidentDataAccess(year) # avoid to save duplicated data with lock: is_deleted = ttincident_da.delete_range(ttri.id, prd.start_date, prd.end_date, item_ids=[v.id for v in all_incidents]) if not is_deleted or not ttincident_da.commit(): ttincident_da.rollback() ttincident_da.close_session() getLogger(__name__).warning('! incident.categorize(): fail to delete existing data') return -1 dict_data = [] for idx, tti in enumerate(ttdata): incds = _find_incident(incd_locations, tti.str2datetime(tti.time)) for (dist, off_dist, incd) in incds: dict_data.append({ 'tt_id': tti.id, 'incident_id': incd.id, 'distance': dist, 'off_distance': off_dist }) if dict_data: with lock: inserted_ids = ttincident_da.bulk_insert(dict_data) if not inserted_ids or not ttincident_da.commit(): ttincident_da.rollback() ttincident_da.close_session() getLogger(__name__).warning('! incident.categorize(): fail to insert categorization data') return -1 ttincident_da.close_session() return len(dict_data)
def categorize(ttri, prd, ttdata, **kwargs): """ :type ttri: pyticas_tetres.ttypes.TTRouteInfo :type prd: pyticas.ttypes.Period :type ttdata: list[pyticas_tetres.ttypes.TravelTimeInfo] :return: """ lock = kwargs.get('lock', nonop_with()) snmDA = SnowMgmtDataAccess() ttsnmDA = TTSnowManagementDataAccess(prd.start_date.year, session=snmDA.get_session()) given_snowmgmts = kwargs.get('snowmgmts', None) snowmgmts = given_snowmgmts or snmDA.list_by_period( prd.start_date, prd.end_date, set_related_model_info=True) snmis = _decide_location(ttri, snowmgmts) with lock: is_deleted = ttsnmDA.delete_range(ttri.id, prd.start_date, prd.end_date, item_ids=[v.id for v in snowmgmts]) if not is_deleted or not ttsnmDA.commit(): ttsnmDA.rollback() ttsnmDA.close_session() getLogger(__name__).warning( '! snowmgmt.categorize(): fail to delete existing data') return -1 dict_data = [] for idx, tti in enumerate(ttdata): dt = tti.str2datetime(tti.time) _snmis = _find_snowmgmts(snmis, dt) for (loc_type, distance, off_distance, snmi, r) in _snmis: dict_data.append({ 'tt_id': tti.id, 'snowmgmt_id': snmi.id, 'loc_type': loc_type.value, 'distance': distance, 'off_distance': off_distance, 'road_status': -1, }) if dict_data: with lock: inserted_ids = ttsnmDA.bulk_insert(dict_data, print_exception=True) if not inserted_ids or not ttsnmDA.commit(): ttsnmDA.rollback() ttsnmDA.close_session() getLogger(__name__).warning( '! snowmgmt.categorize(): fail to insert categorized data') return -1 ttsnmDA.close_session() return len(dict_data)
def calculate_a_route(prd, ttri, **kwargs): """ :type prd: pyticas.ttypes.Period :type ttri: pyticas_tetres.ttypes.TTRouteInfo """ logger = getLogger(__name__) dbsession = kwargs.get('dbsession', None) if dbsession: da_tt = TravelTimeDataAccess(prd.start_date.year, session=dbsession) else: da_tt = TravelTimeDataAccess(prd.start_date.year) creatable_list = list() lock = kwargs.get('lock', nonop_with()) # delete data to avoid duplicated data with lock: is_deleted = da_tt.delete_range(ttri.id, prd.start_date, prd.end_date, print_exception=True) if not is_deleted or not da_tt.commit(): logger.warning('fail to delete the existing travel time data') if not dbsession: da_tt.close_session() return False print(f"{Fore.GREEN}CALCULATING TRAVEL-TIME FOR ROUTE[{ttri.name}]") res_dict = _calculate_tt(ttri.route, prd) if not res_dict or not res_dict['tt']: logger.warning('fail to calculate travel time') return False travel_time_results = res_dict['tt'] travel_time = travel_time_results[-1].data avg_speeds = _route_avgs(res_dict['speed']) res_vmt = _route_total(res_dict['vmt']) timeline = prd.get_timeline(as_datetime=False, with_date=True) print(f"{Fore.CYAN}Start[{timeline[0]}] End[{timeline[-1]}] TimelineLength[{len(timeline)}]") for index, dateTimeStamp in enumerate(timeline): tt_data = { 'route_id': ttri.id, 'time': dateTimeStamp, 'tt': travel_time[index], 'speed': avg_speeds[index], 'vmt': res_vmt[index], } creatable_list.append(tt_data) inserted_ids = list() if creatable_list: with lock: inserted_ids = da_tt.bulk_insert(creatable_list) if not inserted_ids or not da_tt.commit(): logger.warning('fail to insert the calculated travel time into database') if not dbsession: da_tt.close_session() return inserted_ids
def update_moe_values_a_route(prd, ttri_id, **kwargs): """ :type prd: pyticas.ttypes.Period :type ttri: pyticas_tetres.ttypes.TTRouteInfo """ import json dbsession = kwargs.get('dbsession', None) if dbsession: da_tt = TravelTimeDataAccess(prd.start_date.year, session=dbsession) else: da_tt = TravelTimeDataAccess(prd.start_date.year) rw_moe_param_json = kwargs.get("rw_moe_param_json") updatable_dict = {} existing_data_list = da_tt.list_by_period(ttri_id, prd) for existing_data in existing_data_list: meta_data = json.loads(existing_data.meta_data) updatable_data = dict() if meta_data.get('moe_congestion_threshold_speed') != rw_moe_param_json.get( 'rw_moe_congestion_threshold_speed'): cm = (calculate_cm_dynamically(meta_data, rw_moe_param_json.get('rw_moe_congestion_threshold_speed'))) cmh = (calculate_cmh_dynamically(meta_data, TT_DATA_INTERVAL, rw_moe_param_json.get('rw_moe_congestion_threshold_speed'))) if existing_data.cm != cm: updatable_data['cm'] = cm if existing_data.cmh != cmh: updatable_data['cmh'] = cmh meta_data['moe_congestion_threshold_speed'] = rw_moe_param_json.get('rw_moe_congestion_threshold_speed') updatable_data['meta_data'] = json.dumps(meta_data) if meta_data.get('moe_lane_capacity') != rw_moe_param_json.get('rw_moe_lane_capacity') or meta_data.get( 'moe_critical_density') != rw_moe_param_json.get('rw_moe_critical_density'): lvmt = calculate_lvmt_dynamically(meta_data, TT_DATA_INTERVAL, rw_moe_param_json.get('rw_moe_critical_density'), rw_moe_param_json.get('rw_moe_lane_capacity')) uvmt = calculate_uvmt_dynamically(meta_data, TT_DATA_INTERVAL, rw_moe_param_json.get('rw_moe_critical_density'), rw_moe_param_json.get('rw_moe_lane_capacity')) if existing_data.lvmt != lvmt: updatable_data['lvmt'] = lvmt if existing_data.uvmt != uvmt: updatable_data['uvmt'] = uvmt meta_data['moe_lane_capacity'] = rw_moe_param_json.get('rw_moe_lane_capacity') meta_data['moe_critical_density'] = rw_moe_param_json.get('rw_moe_critical_density') updatable_data['meta_data'] = json.dumps(meta_data) if updatable_data: updatable_dict[existing_data.id] = updatable_data lock = kwargs.get('lock', nonop_with()) if updatable_dict: with lock: for id, updatable_data in updatable_dict.items(): da_tt.update(id, updatable_data) da_tt.commit() da_tt.close_session()
def calculate_all_routes(prd, **kwargs): """ calculate travel time, average speed and VMT during the given time period and put whole_data to database (travel time table) :type prd: pyticas.ttypes.Period :rtype: list[dict] """ logger = getLogger(__name__) logger.info('calculating travel time : %s' % prd.get_period_string()) res = [] ttr_route_da = TTRouteDataAccess() routes = ttr_route_da.list() ttr_route_da.close_session() total = len(routes) for ridx, ttri in enumerate(routes): logger.info('(%d/%d) calculating travel time for %s(%s) : %s' % ((ridx + 1), total, ttri.name, ttri.id, prd.get_period_string())) is_inserted = calculate_a_route(prd, ttri, lock=kwargs.get('lock', nonop_with())) res.append({'route_id': ttri.id, 'done': is_inserted}) return res
def calculate_tt_moe_a_route(prd, ttri, **kwargs): """ :type prd: pyticas.ttypes.Period :type ttri: pyticas_tetres.ttypes.TTRouteInfo """ logger = getLogger(__name__) dbsession = kwargs.get('dbsession', None) create_or_update = kwargs.get("create_or_update", True) rw_moe_param_json = kwargs.get("rw_moe_param_json") if rw_moe_param_json: moe_param_config = RouteWiseMOEParametersInfo() moe_param_config.moe_lane_capacity = rw_moe_param_json.get('rw_moe_lane_capacity') moe_param_config.moe_critical_density = rw_moe_param_json.get('rw_moe_critical_density') moe_param_config.moe_congestion_threshold_speed = rw_moe_param_json.get('rw_moe_congestion_threshold_speed') else: moe_param_config = get_system_config_info() if dbsession: da_tt = TravelTimeDataAccess(prd.start_date.year, session=dbsession) else: da_tt = TravelTimeDataAccess(prd.start_date.year) creatable_list = list() updatable_dict = {} existing_data_dict = {} if create_or_update: existing_data_list = da_tt.list_by_period(ttri.id, prd) for existing_data in existing_data_list: existing_data_dict[(existing_data.route_id, existing_data.time)] = existing_data lock = kwargs.get('lock', nonop_with()) if not create_or_update: # delete data to avoid duplicated data with lock: is_deleted = da_tt.delete_range(ttri.id, prd.start_date, prd.end_date, print_exception=True) if not is_deleted or not da_tt.commit(): logger.warning('fail to delete the existing travel time data') if not dbsession: da_tt.close_session() return False # latest_moe_parameter_object = None # try: # rw_moe_da = RouteWiseMOEParametersDataAccess() # latest_moe_parameter_object = rw_moe_da.get_latest_moe_param_for_a_route(ttri.id) # rw_moe_da.close_session() # except Exception as e: # logger = getLogger(__name__) # logger.warning('fail to fetch the latest MOE parameter for this route. Error: {}'.format(e)) print(f"{Fore.GREEN}CALCULATING TRAVEL-TIME FOR ROUTE[{ttri.name}]") res_dict = _calculate_tt_moe(ttri.route, prd) if not res_dict: logger.warning('fail to calculate travel time') return False flow_data, raw_flow_data = res_dict["flow_data"] density_data, raw_density_data = res_dict['density_data'] speed_data_without_virtual_node, speed_data, raw_speed_data = res_dict["speed_data"] travel_time_results = res_dict['tt'] res_mrf = res_dict["mrf"] travel_time = travel_time_results[-1].data avg_speeds = _route_avgs(speed_data_without_virtual_node) accelerator_data = _raw_route_avgs(_calculate_accel(speed_data_without_virtual_node, prd.interval, **kwargs), prd) timeline = prd.get_timeline(as_datetime=False, with_date=True) print(f"{Fore.CYAN}Start[{timeline[0]}] End[{timeline[-1]}] TimelineLength[{len(timeline)}]") for index, dateTimeStamp in enumerate(timeline): meta_data = generate_meta_data(raw_flow_data, raw_speed_data, raw_density_data, flow_data, speed_data, density_data, speed_data_without_virtual_node, res_mrf, moe_param_config, index) meta_data_string = json.dumps(meta_data) interval = TT_DATA_INTERVAL moe_critical_density = moe_param_config.moe_critical_density moe_lane_capacity = moe_param_config.moe_lane_capacity moe_congestion_threshold_speed = moe_param_config.moe_congestion_threshold_speed vmt = calculate_vmt_dynamically(meta_data, interval) vht = calculate_vht_dynamically(meta_data, interval) dvh = calculate_dvh_dynamically(meta_data, interval) lvmt = calculate_lvmt_dynamically(meta_data, interval, moe_critical_density, moe_lane_capacity) uvmt = calculate_uvmt_dynamically(meta_data, interval, moe_critical_density, moe_lane_capacity) cm = calculate_cm_dynamically(meta_data, moe_congestion_threshold_speed) cmh = calculate_cmh_dynamically(meta_data, interval, moe_congestion_threshold_speed) tt_data = { 'route_id': ttri.id, 'time': dateTimeStamp, 'tt': travel_time[index], 'speed': avg_speeds[index], 'vmt': vmt, 'vht': vht, 'dvh': dvh, 'lvmt': lvmt, 'uvmt': uvmt, 'cm': cm, 'cmh': cmh, 'acceleration': accelerator_data[index], 'meta_data': meta_data_string, } if create_or_update: existing_data = existing_data_dict.get((tt_data['route_id'], tt_data['time'])) if existing_data: updatable_dict[existing_data.id] = tt_data else: creatable_list.append(tt_data) else: creatable_list.append(tt_data) inserted_ids = list() if creatable_list: with lock: inserted_ids = da_tt.bulk_insert(creatable_list) if not inserted_ids or not da_tt.commit(): logger.warning('fail to insert the calculated travel time into database') if not inserted_ids: inserted_ids = list() if updatable_dict: with lock: for id, tt_data in updatable_dict.items(): da_tt.update(id, generate_updatable_moe_dict(tt_data)) inserted_ids.append(id) da_tt.commit() if not dbsession: da_tt.close_session() return inserted_ids
def categorize(ttri, prd, ttdata, **kwargs): """ :type ttri: pyticas_tetres.ttypes.TTRouteInfo :type prd: pyticas.ttypes.Period :type ttdata: list[pyticas_tetres.ttypes.TravelTimeInfo] :return: """ lock = kwargs.get('lock', nonop_with()) given_wzs = kwargs.get('workzones', None) wzs = given_wzs or wz_helper.find_workzones(prd) workzones = [] for wzi in wzs: loc_type, distance, off_distance = loc.location(ttri.route, wzi.route1) r = wzi.route1 if loc_type == None: # distance : distance between the most upstream rnodes # off-distance : 0 if it is overlapeed, # negative : workzone is located in upstream of the route # positive : workzone is located in downstream of the route loc_type, distance, off_distance = loc.location( ttri.route, wzi.route2) r = wzi.route2 if loc_type == None: continue if (loc_type == LOC_TYPE.DOWN and off_distance > WZ_DOWNSTREAM_DISTANCE_LIMIT or loc_type == LOC_TYPE.UP and abs(off_distance) > WZ_UPSTREAM_DISTANCE_LIMIT): continue workzones.append((loc_type, distance, off_distance, wzi, r)) year = prd.start_date.year da_tt_wz = TTWorkZoneDataAccess(year) # avoid to save duplicated data with lock: is_deleted = da_tt_wz.delete_range(ttri.id, prd.start_date, prd.end_date, item_ids=[v.id for v in wzs]) if not is_deleted or not da_tt_wz.commit(): da_tt_wz.close_session() getLogger(__name__).warning( '! workzone.categorize(): fail to delete existing data') return -1 dict_data = [] for idx, tti in enumerate(ttdata): wzs = _find_wzs(workzones, tti.str2datetime(tti.time)) for (loc_type, distance, off_distance, wzi, r) in wzs: dict_data.append({ 'tt_id': tti.id, 'workzone_id': wzi.id, 'loc_type': loc_type.value, 'distance': distance, 'off_distance': off_distance }) if dict_data: with lock: inserted_ids = da_tt_wz.bulk_insert(dict_data, print_exception=True) if not inserted_ids or not da_tt_wz.commit(): da_tt_wz.rollback() da_tt_wz.close_session() getLogger(__name__).warning( '! workzone.categorize(): fail to insert categorized data') return -1 da_tt_wz.close_session() return len(dict_data)
def categorize(ttri, prd, ttdata, **kwargs): """ :type ttri: pyticas_tetres.ttypes.TTRouteInfo :type prd: pyticas.ttypes.Period :type ttdata: list[pyticas_tetres.ttypes.TravelTimeInfo] :rtype: int """ lock = kwargs.get('lock', nonop_with()) # prepare : coordinates, target year lat, lon = route.center_coordinates(ttri.route) year = prd.start_date.year # nearby weather station list all_isd_stations = isd.get_station_list('MN', None, False) isd_stations = isd.find_nearby_station(lat, lon, prd.start_date.date(), all_isd_stations) station_idx = 0 if not isd_stations or not isd_stations[station_idx]: getLogger(__name__).warn( '! weather.categorize(): no weather information for TTRI(%d)' % (ttri.id)) return -1 nearby = isd_stations[station_idx][1] cprd = prd.clone() cprd.extend_start_hour(1) cprd.extend_end_hour(1) # decide nearby weather station which has data during a given period # by trying to read weather data wiss = [] hours = (len(cprd.get_timeline()) * prd.interval) / 60 / 60 da_noaa = NoaaWeatherDataAccess(year) while True: nearby = isd_stations[station_idx][1] distance = isd_stations[station_idx][0] if distance > WEATHER_STATION_DISTANCE_LIMIT: nearby = None break wis = da_noaa.list_by_period(nearby.usaf, nearby.wban, cprd) if len(wis) < hours * 0.6: station_idx += 1 continue if wis: break # if wis: # wiss.append(wis) # if len(wiss) >= 3: # break # continue if station_idx >= len(isd_stations) - 1: nearby = None break if not nearby: getLogger(__name__).warn( '! weather.categorize(): no weather information for TTRI(%d)' % (ttri.id)) da_noaa.close_session() return -1 da_ttw = TTWeatherDataAccess(year) # avoid to save duplicated data with lock: is_deleted = da_ttw.delete_range(ttri.id, prd.start_date, prd.end_date) if not is_deleted or not da_ttw.commit(): da_ttw.rollback() da_ttw.close_session() # shared session with `da_noaa` da_noaa.close_session() return -1 # insert weather data to database sidx = 0 dict_data = [] for idx, tti in enumerate(ttdata): sidx, wd = _find_wd(wis, tti.time, sidx) if not wd: getLogger(__name__).warn( '! weather.categorize(): weather data is not found for (tti.time=%s, usaf=%s, wban=%s)' % (tti.time, wis[-1].usaf, wis[-1].wban)) continue dict_data.append({'tt_id': tti.id, 'weather_id': wd.id}) if dict_data: with lock: inserted_ids = da_ttw.bulk_insert(dict_data, print_exception=True) if not inserted_ids or not da_ttw.commit(): getLogger(__name__).warn( '! weather.categorize() fail to insert categorized data') da_ttw.rollback() da_ttw.close_session() da_noaa.close_session() return -1 da_noaa.close_session() da_ttw.close_session() return len(dict_data)
def _calculate_for_a_regime(ttri, regime_type, sdate, edate, stime, etime, target_days=(1, 2, 3), except_dates=(), remove_holiday=True, **kwargs): """ :type ttri: pyticas_tetres.ttypes.TTRouteInfo :type regime_type: int :type sdate: datetime.date :type edate: datetime.date :type stime: datetime.time :type etime: datetime.time :type target_days: tuple[int] :rtype: bool """ # Regime Filter ext_filter = _ext_filter(regime_type) lock = kwargs.get('lock', nonop_with()) extractor.extract_tt(ttri.id, sdate, edate, stime, etime, [ext_filter], target_days=target_days, remove_holiday=remove_holiday, except_dates=except_dates) # print('# ', ext_filter.label) da = TODReliabilityDataAccess() # delete existings ttwis = [ttwi for ttwi in da.list_by_route(ttri.id, regime_type)] ttwi_ids = [v.id for v in ttwis] with lock: is_deleted = da.delete_items(ttwi_ids) if not is_deleted or not da.commit(): return False tod_res = [] cursor = datetime.datetime.combine(datetime.date.today(), stime) cursor += datetime.timedelta(seconds=cfg.TT_DATA_INTERVAL) edatetime = datetime.datetime.combine(datetime.date.today(), etime) dict_data = [] while cursor <= edatetime: ctime = cursor.strftime('%H:%M:00') res = [ extdata for extdata in ext_filter.whole_data if ctime == extdata.tti.time.strftime('%H:%M:00') ] ttr_res = reliability.calculate(ttri, res) tod_res.append(ttr_res) dict_data.append({ 'regime_type': regime_type, 'route_id': ttri.id, 'hour': cursor.hour, 'minute': cursor.minute, 'result': json.dumps(ttr_res), }) cursor += datetime.timedelta(seconds=cfg.TT_DATA_INTERVAL) with lock: is_inserted = da.bulk_insert(dict_data) if not is_inserted or not da.commit(): return False return True
def calculate_TOD_reliabilities(ttr_id, today, **kwargs): """ :type ttr_id: int :type today: datetime.datetime """ ttri = _tt_route(ttr_id) sdate, edate, stime, etime = _time_period(today) lock = kwargs.get('lock', nonop_with()) # _calculate_for_a_regime(ttri, TOD_REGIME_N_0, WC_RAIN, sdate, edate, stime, etime, (1, 2, 3)) # Normal, Tuesday-Thursday _calculate_for_a_regime(ttri, TOD_REGIME_N_0, sdate, edate, stime, etime, (0, ), lock=lock) # Normal, Monday _calculate_for_a_regime(ttri, TOD_REGIME_N_123, sdate, edate, stime, etime, (1, 2, 3), lock=lock) # Normal, Tuesday-Thursday _calculate_for_a_regime(ttri, TOD_REGIME_N_4, sdate, edate, stime, etime, (4, ), lock=lock) # Normal, Friday _calculate_for_a_regime(ttri, TOD_REGIME_N_56, sdate, edate, stime, etime, (5, 6), lock=lock) # Normal, Saturday-Sunday _calculate_for_a_regime(ttri, TOD_REGIME_R_0, sdate, edate, stime, etime, (0, ), lock=lock) # Rain, Monday _calculate_for_a_regime(ttri, TOD_REGIME_R_123, sdate, edate, stime, etime, (1, 2, 3), lock=lock) # Rain, Tuesday-Thursday _calculate_for_a_regime(ttri, TOD_REGIME_R_4, sdate, edate, stime, etime, (4, ), lock=lock) # Rain, Friday _calculate_for_a_regime(ttri, TOD_REGIME_R_56, sdate, edate, stime, etime, (5, 6), lock=lock) # Rain, Saturday-Sunday _calculate_for_a_regime(ttri, TOD_REGIME_S_0, sdate, edate, stime, etime, (0, ), lock=lock) # Snow, Monday _calculate_for_a_regime(ttri, TOD_REGIME_S_123, sdate, edate, stime, etime, (1, 2, 3), lock=lock) # Snow, Tuesday-Thursday _calculate_for_a_regime(ttri, TOD_REGIME_S_4, sdate, edate, stime, etime, (4, ), lock=lock) # Snow, Friday _calculate_for_a_regime(ttri, TOD_REGIME_S_56, sdate, edate, stime, etime, (5, 6), lock=lock) # Snow, Saturday-Sunday