def _decide_wn2_reduction_interval(edata, usidx, ueidx, after_congested_idx):
"""
:type edata: pyticas_ncrtes.core.etypes.ESTData
:type after_congested_idx: int
:rtype:
"""
rth = 0.8
tmp_recovered_u_th = 20
edata.should_wn_uk_without_ffs = True
sidx, eidx = max(usidx - setting.INTV1HOUR,
0), min(usidx + setting.INTV1HOUR, edata.n_data - 1)
maxu_idx = np.argmax(edata.sus[sidx:eidx]).item() + sidx
if edata.sratios[maxu_idx] < rth and edata.lsratios[maxu_idx] < rth:
getLogger(__name__).debug(
' - temporary recovered area is not found according to normal ratio (maxu_idx=%d, r=%f)'
% (maxu_idx, edata.normal_ratios[maxu_idx]))
edata.should_wn_uk_without_ffs = False
return True
edata.wn2_interval_sidx = maxu_idx
edata.wn2_interval_eidx = maxu_idx
for idx in range(maxu_idx, edata.n_data):
if edata.sus[idx] < tmp_recovered_u_th:
break
edata.wn2_interval_eidx = idx
getLogger(__name__).debug(
' - wn2_interval (%d - %d), after_congestion_idx=%d' %
(maxu_idx, usidx, edata.wn2_after_congestion_idx))
return True
def _update_ncrt(target_ncrt, edata):
"""
:param target_ncrt:
:type target_ncrt: int
:param edata:
:type edata: pyticas_ncrtes.core.etypes.ESTData
"""
getLogger(__name__).debug(
' - update : %s %s => %s' %
(edata.target_station.station_id, edata.ncrt, target_ncrt))
edata.own_ncrt = edata.ncrt
edata.ncrt = target_ncrt
def estimate(num, tsi, edata):
"""
:type num: int
:type tsi: pyticas_ncrtes.itypes.TargetStationInfo
:type edata: pyticas_ncrtes.core.etypes.ESTData
:rtype: pyticas_ncrtes.core.etypes.ESTData
"""
if not _check_edata(tsi, edata):
return edata
logger = getLogger(__name__)
logger.info('>>> Determine NCRT Process for Target Station %s' % (edata.target_station.station_id))
try:
_pre_process_before_determination(edata)
has_recovered_region = wnffs_finder.find(edata)
if not has_recovered_region:
_chart(edata, edata.ratios, edata.lsratios, edata.sratios)
return
wn_uk.make(edata)
ncrt_finder.find(edata)
_chart(edata, edata.ratios, edata.lsratios, edata.sratios)
except Exception as ex:
logger.error(tb.traceback(ex, f_print=False))
logger.info('<<< End of NCRT Determination Process for Target Station %s' % (edata.target_station.station_id))
return edata
def target_station_and_snowroute_info(year):
infra = Infra.get_infra()
logger = getLogger(__name__)
logger.info(
'>>> updating relations between target station and truck route')
from pyticas_ncrtes.da.snowroute import SnowRouteDataAccess
from pyticas_ncrtes.da.target_station import TargetStationDataAccess
snrDA = SnowRouteDataAccess()
tsDA = TargetStationDataAccess()
snow_routes = snrDA.list_by_year(year)
target_stations = tsDA.list_by_year(year, as_model=True)
for tidx, ts in enumerate(target_stations):
rnode = infra.get_rnode(ts.station_id)
if not rnode:
continue
for snri in snow_routes:
if rnode in snri.route1.rnodes or rnode in snri.route2.rnodes:
ts.snowroute_id = snri.id
ts.snowroute_name = snri._snowroute_group.name
if tidx and tidx % 100:
snrDA.commit()
snrDA.commit()
snrDA.close()
tsDA.close()
logger.info(
'<<< end of updating relations between target station and truck route')
def _reported_events(request_param):
"""
:type request_param: pyticas_ncrtes.itypes.EstimationRequestInfo
:rtype: dict[str, list[ReportedEvent]]
"""
logger = getLogger(__name__)
reported_events = {}
if hasattr(request_param, 'barelane_regain_time_infos'
) and request_param.barelane_regain_time_infos:
for brt in request_param.barelane_regain_time_infos:
# logger.debug(' > truck_id=%s, start=%s, end=%s, lost=%s, regain=%s' % (
# brt.truckroute_id,
# brt.snow_start_time,
# brt.snow_end_time,
# brt.lane_lost_time,
# brt.barelane_regain_time
# ))
reported = etypes.ReportedEvent(brt.truckroute_id,
brt.snow_start_time,
brt.snow_end_time,
brt.lane_lost_time,
brt.barelane_regain_time)
rbtlist = reported_events.get(brt.truckroute_id, [])
rbtlist.append(reported)
reported_events[brt.truckroute_id] = rbtlist
return reported_events
def make(daytime_data):
""" makes NSR function with the collected normal dry day data
:type daytime_data: pyticas_ncrtes.core.etypes.DaytimeData
:rtype: pyticas_ncrtes.core.etypes.DaytimeFunction, dict[float, float]
"""
# Procedure
# 1. validate recovery and reduction speed-density data respectively
# 2. calibrate normal speed recovery function
# 3. calibrate normal speed reduction function
logger = getLogger(__name__)
logger.debug('>> %s : try to make normal u-k function' %
daytime_data.station.station_id)
recovery_uk = _filter_splited_patterns(daytime_data.recovery_uk)
recovery_uk_origin = daytime_data.recovery_uk
recovery_function = _segmented_function(daytime_data, recovery_uk,
recovery_uk_origin)
daytime_function = etypes.DaytimeFunction(daytime_data.station,
recovery_function)
logger.debug(' -> ffs=%s, is_valud=%s' %
(daytime_function.get_FFS(),
daytime_function.recovery_function.is_valid()))
return daytime_function
def find(edata):
"""
:type edata: pyticas_ncrtes.core.etypes.ESTData
"""
logger = getLogger(__name__)
logger.debug(' >>> ncrt_finder.find() : wn_ffs_idx=%s, wn_ffs=%s' %
(edata.wn_ffs_idx, edata.wn_ffs))
has_normal_uk_function = edata.normal_func.is_valid()
if has_normal_uk_function and edata.wn_ffs_idx:
logger.debug(' - determine NCRT with wet-normal uk function')
_determine_with_wnuk(edata)
elif has_normal_uk_function and edata.should_wn_uk_without_ffs:
if edata.wn2_interval_sidx:
logger.debug(
' - determine NCRT with wet-normal uk function (recovered-from-congested)'
)
# recovered from congestion
_determine_ncrt_from_congestion(edata)
else:
# NCRT cannot be determined
logger.debug(
' - cannot determine NCRT (recovered-from-congested)')
elif edata.wn_ffs_idx:
logger.debug(' - determine NCRT without wet-normal uk function')
edata.ncrt = _adjust_with_speed(edata, edata.wn_ffs_idx)
else:
logger.debug(' - cannot determine NCRT')
if edata.ncrt and edata.ncrt_search_sidx and edata.ncrt < edata.ncrt_search_sidx:
edata.ncrt = edata.wn_ffs_idx
logger.debug(' <<< end of ncrt_finder.find() ')
def report(case_name, edata_list, output_path):
"""
:type case_name: str
:type edata_list: list[pyticas_ncrtes.core.etypes.ESTData]
:type output_path: str
:return:
"""
logger = getLogger(__name__)
# preparing output folder
chart_path = os.path.join(output_path, 'charts')
if not os.path.exists(chart_path):
os.makedirs(chart_path)
speed_countour_file = os.path.join(output_path, '%s-speed.png' % case_name)
speed_contour.write(speed_countour_file, case_name, edata_list)
# normal_ratio_countour_file = os.path.join(output_path, '%s-normal_ratio.png' % case_name)
# wetnormal_ratio_countour_file = os.path.join(output_path, '%s-wetnormal_ratio.png' % case_name)
# ratio_contour.write(normal_ratio_countour_file, wetnormal_ratio_countour_file, case_name, edata_list)
summary_file = os.path.join(output_path, '%s.xlsx' % case_name)
summary.write(summary_file, case_name, edata_list)
station_chart.write(chart_path, case_name, edata_list)
logger.debug('The whole_data are saved in %s' % output_path)
def initialize_database():
logger = getLogger(__name__)
logger.info(' - initialize database : add default nsr_data')
from pyticas_ncrtes.db import conn
conn.engine.execute("INSERT INTO config (name, content) VALUES ('version', '{}')".format(__DB_VERSION__))
def is_dry_day(target_station, prd):
""" is dry day?
How-to::
check weather through RWIS at first,
if RWIS is not available, use weather sensor (WEATHER_DEVICE.WS35W25)
:type target_station: pyticas.ttypes.RNodeObject
:type prd: pyticas.ttypes.Period
:rtype: (bool, str)
"""
logger = getLogger(__name__)
# wbans = [wban for (usaf, wban) in TARGET_ISD_STATIONS]
# usafs = [usaf for (usaf, wban) in TARGET_ISD_STATIONS]
# _weather_stations = isd.get_station_list('MN', lambda wst: wst.wban in wbans and wst.usaf in usafs)
# isd_stations = isd.find_nearby_station(target_station.lat, target_station.lon, prd.start_date.date(), _weather_stations)
isd_stations = weather_stations(target_station, prd)
nearby = None
isd_data_list = None
cprd = prd.clone()
cprd.extend_end_hour(2)
# decide nearby weather station which has nsr_data during a given period
# by trying to read weather nsr_data
for dist, isd_station in isd_stations:
cache_key = '%s-%s' % (isd_station.station_name, prd.get_period_string())
if cache_key in DRY_DAY_CACHE:
nearby, isd_data_list = DRY_DAY_CACHE[cache_key]
break
if dist > WEATHER_STATION_DISTANCE_LIMIT:
break
isd_data_list = isd.get_data(isd_station, cprd)
""":type: list[pyticas_noaa.isd.isdtypes.ISDData] """
if not isd_data_list:
continue
DRY_DAY_CACHE[cache_key] = (isd_station, isd_data_list)
nearby = isd_station
break
if not nearby:
#logger.warning('No weather information (for %s during %s)' % (target_station.station_id, prd.get_period_string()))
return False, None
if _is_dry(isd_data_list, prd, setting.DRY_RATE_THRESHOLD):
return True, nearby.station_name
else:
return False, nearby.station_name
def _may_recovered_speed(edata, rth=0.9):
"""
:type edata: pyticas_ncrtes.core.etypes.ESTData
:rtype:
"""
getLogger(__name__).debug(' - Snowday FFS : %s' % edata.snowday_ffs)
normal_ffs = edata.normal_ffs
snowday_ffs = edata.snowday_ffs
if normal_ffs and snowday_ffs:
return max(normal_ffs, snowday_ffs) * rth
if normal_ffs:
return normal_ffs* rth
if snowday_ffs:
return snowday_ffs * rth
return None
def write(output_dir, name, edata_list, prefix=''):
"""
:type output_dir: str
:type name: str
:type edata_list: list[pyticas_ncrtes.core.etypes.ESTData]
"""
logger = getLogger(__name__)
for idx, edata in enumerate(edata_list):
logger.debug('Writing chart image of %s' %
edata.target_station.station_id)
# if edata.ncrt or (not edata.pst and not edata.stable_speed_region_before_pst and not edata.stable_speed_region_after_pst):
# continue
_write(idx, edata, output_dir, prefix)
def write(filepath, name, edata_list):
"""
:type filepath: str
:type name: str
:type edata_list: list[pyticas_ncrtes.core.etypes.ESTData]
"""
logger = getLogger(__name__)
logger.debug('Writing summary sheets of %s' % name)
nonon_edata_list = [
edata for edata in edata_list if edata is not None and edata.is_loaded
]
results = [_get_summary_from_edata(edata) for edata in nonon_edata_list]
_write_summary_xlsx(results, nonon_edata_list, filepath)
def connect(DB_INFO):
"""
:rtype: (sqlalchemy.engine.Engine, sqlalchemy.engine.Connection, sqlalchemy.orm.scoped_session)
"""
logger = getLogger(__name__)
logger.info('creating database connection...')
# for SQLite
engine = create_engine('sqlite:///' + os.path.join(get_path('db'), DB_INFO['filename']))
connection = engine.connect()
model.Base.metadata.bind = engine
session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)
return (engine, connection, Session)
def _get_timepoint_data(n_data, get_func, ignore_ex=True):
_data = [None] * n_data
_time = get_func(as_string=False)
if _time:
if isinstance(_time, list):
for _t in _time:
try:
_point = edata.snow_event.time_to_index(_t)
_data[_point] = edata.sus[_point]
except Exception as ex:
if not ignore_ex:
raise ex
else:
getLogger(__name__).error(str(ex))
else:
try:
_point = edata.snow_event.time_to_index(_time)
_data[_point] = edata.sus[_point]
except Exception as ex:
if not ignore_ex:
raise ex
else:
getLogger(__name__).warn(str(ex))
return _data
def register_service(self, server):
""" register web services to the Flask server
:type server: flask.Flask
:rtype:
"""
logger = getLogger(__name__)
logger.info(' - registering {}'.format(self.name))
# import API modules
from pyticas_ncrtes.api import handlers
for module in handlers:
module.register_api(server)
def _after_kt(station, uk, Kt):
""" make exponential decay function
:type station: pyticas.ttypes.RNodeObject
:type uk: dict[float, float]
:type Kt: float
:rtype: etypes.LogFunction
"""
fit_func = lambda x, a, b: a * x + b
target_us, target_ks = data_util.dict2sorted_list(
uk, key_filter=lambda k: k > Kt)
knots = _knots(np.array(target_ks), np.array(target_us), fit_func, 1)
knot = knots[0]
for knot in range(int(knots[0]), int(Kt), -2):
_target_us, _target_ks = data_util.dict2sorted_list(
uk, key_filter=lambda k: k > knot)
if len(_target_ks) > 50:
target_ks, target_us = _target_ks, _target_us
break
popts = [90, 0.02]
target_ks = target_ks + [200]
target_us = target_us + [2]
N = len(target_ks)
sigma = np.ones(N)
sigma[-1] = 0.01
try:
info, popts, rep, func = fitting.curve_fit(
etypes.LogFunction.get_fitting_function(), target_ks, target_us,
popts)
return etypes.LogFunction(popts, {}, Kt)
except Exception as ex:
getLogger(__name__).warn('cannot calibrate linear function')
return etypes.LogFunction(None, {}, Kt)
def _snow_routes(year):
"""
:type year: int
:rtype: list[SnowRoute], list[from pyticas_ncrtes.itypes.SnowRouteInfo]
"""
logger = getLogger(__name__)
da_snrg = SnowRouteGroupDataAccess()
da_snr = SnowRouteDataAccess()
snrgi_list = da_snrg.search([('year', year)], group_by='name')
snri_list = []
for snrgi in snrgi_list:
_snri_list = da_snr.search([('snowroute_group_id', snrgi.id)])
if _snri_list:
snri_list.extend(_snri_list)
snow_routes = []
for snri in snri_list:
# logger.debug(' > snow route : %s, %s, %s, %s' % (
# snri.id, snri._snowroute_group.region, snri._snowroute_group.sub_region, snri._snowroute_group.name
# ))
sr1 = etypes.SnowRoute(snri._snowroute_group.region,
snri._snowroute_group.sub_region,
snri._snowroute_group.name, '',
snri.route1.corridors()[0].route,
snri.route1.corridors()[0].dir,
snri.route1.get_stations()[0].station_id,
snri.route1.get_stations()[-1].station_id,
snri.name, snri.description)
sr2 = etypes.SnowRoute(snri._snowroute_group.region,
snri._snowroute_group.sub_region,
snri._snowroute_group.name, '',
snri.route2.corridors()[0].route,
snri.route2.corridors()[0].dir,
snri.route2.get_stations()[0].station_id,
snri.route2.get_stations()[-1].station_id,
snri.name, snri.description)
# logger.debug(' - %s' % sr1)
# logger.debug(' - %s' % sr2)
snow_routes.append(sr1)
snow_routes.append(sr2)
return snow_routes, snri_list
def _station_data(target_station, prd, dc):
""" return q,k,u data for given period
:type target_station: pyticas.ttypes.RNodeObject
:type prd: pyticas.ttypes.Period
:type dc: function
:rtype: (pyticas.ttypes.RNodeData, pyticas.ttypes.RNodeData, pyticas.ttypes.RNodeData)
"""
rdr = ncrtes.get_infra().rdr
logger = getLogger(__name__)
us = rdr.get_speed(target_station, prd, dc)
if not us or _is_missing_day(us.data, prd.interval):
logger.debug('Station %s is missing at %s!!' % (target_station.station_id, prd.get_date_string()))
return None, None, None
ks = rdr.get_density(target_station, prd, dc)
qs = rdr.get_average_flow(target_station, prd, dc)
return us, ks, qs
def connect(DB_INFO):
"""
:rtype: (sqlalchemy.engine.Engine, sqlalchemy.engine.Connection, sqlalchemy.orm.scoped_session)
"""
logger = getLogger(__name__)
logger.info('creating database connection...')
connection_string = 'postgresql+pg8000://{}:{}@{}:{}/{}'.format(DB_INFO['user'],
DB_INFO['passwd'],
DB_INFO['host'],
DB_INFO['port'],
DB_INFO['db_name'])
engine = create_engine(connection_string, encoding='utf-8')
connection = engine.connect()
model.Base.metadata.bind = engine
session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)
return (engine, connection, Session)
def adjust_ncrts(edata_list, sections):
"""
:type edata_list: list[pyticas_ncrtes.core.etypes.ESTData]
:type sections: list[list[pyticas_ncrtes.core.etypes.ESTData]]
:rtype: float
"""
logger = getLogger(__name__)
logger.debug('>>>>>> Adjust Type1 NCRTs')
for sidx, s in enumerate(sections):
logger.debug('>>>>>>>> Section : %s' %
[edata.target_station.station_id for edata in s])
if any(s):
_adjust_ncrt_for_a_section(s)
logger.debug('<<<<<<<< End of Section : %s' %
[edata.target_station.station_id for edata in s])
logger.debug('<<<<<< End of Adjust Type1 NCRTs')
return edata_list
def make(target_station, normal_months, **kwargs):
"""
:type target_station: pyticas.ttypes.RNodeObject
:type normal_months: list[tuple(int, int)]
:rtype: pyticas_ncrtes.core.etypes.NSRFunction
"""
log = getLogger(__name__)
data = kwargs.get('normal_data', None)
if not data:
data = nsr_data.get(target_station, normal_months, **kwargs)
if not data:
log.warn('Cannot collect normal data for %s' %
target_station.station_id)
return None
dt_func = daytime.make(data.daytime_data)
nt_func = nighttime.make(data.night_data)
return pyticas_ncrtes.core.etypes.NSRFunction(target_station,
normal_months, dt_func,
nt_func)
def _check_edata(tsi, edata):
"""
:type tsi: pyticas_ncrtes.itypes.TargetStationInfo
:type nsr_func: pyticas_ncrtes.core.etypes.NSRFunction
:rtype: bool
"""
log = getLogger(__name__)
if not edata:
log.info('> %s : No ESTData' % tsi.station_id)
return False
if not edata or not edata.is_loaded:
log.info('> %s : Data are not loaded for snow event' % tsi.station_id)
return False
# if not edata.search_start_idx:
# log.info('> %s : No Search Start Idx' % tsi.station_id)
# return False
return True
def prepare_data(tsi, station, year, stime, etime, snow_routes, reported, normal_func):
"""
:type tsi: pyticas_ncrtes.itypes.TargetStationInfo
:type station: pyticas.ttypes.RNodeObject
:type year: int
:type stime: datetime.datetime
:type etime: datetime.datetime
:type snow_routes: list[pyticas_ncrtes.core.etypes.SnowRoute]
:type reported: dict[str, list[pyticas_ncrtes.core.etypes.ReportedEvent]]
:type normal_months: list[(int, int)]
:rtype: pyticas_ncrtes.core.etypes.ESTData
"""
sevent = etypes.SnowEvent(stime, etime)
infra = ncrtes.get_infra()
target_station = infra.get_rnode(tsi.station_id)
tlcDA = TargetLaneConfigDataAccess()
tlci = tlcDA.get_by_station_id(year, station.station_id)
if tlci:
valid_detectors = [infra.get_detector(det_name.strip()) for det_name in tlci.detectors.split(',')]
else:
valid_detectors = target.get_target_detectors(station)
if not valid_detectors:
return None
try:
edata = etypes.ESTData(tsi, target_station, sevent, snow_routes, reported, normal_func)
edata.prepare_data(detectors=valid_detectors)
return edata
except Exception as ex:
log = getLogger(__name__)
log.warning('!!!!! Error : %s : %s' % (tsi.station_id, ex))
from pyticas.tool import tb
tb.traceback(ex)
return None
def get_target_stations(corr_name):
""" Returns potential target stations satisfying the following conditions
**Conditions**
- normal station
- not temporary station
- not wavetronics station
- not radar station
- not velocity station
- has target lanes
- lane 2 or lane 3 (when lane 1 is an auxiliary lane)
- not on curve
- the station on curve shows lower-level of U-K comparing to nearby stations
:type corr_name: str
:rtype: list[pyticas.ttypes.RNodeObject]
"""
logger = getLogger(__name__)
infra = ncrtes.get_infra()
corr = infra.get_corridor_by_name(corr_name)
stations = []
for st in corr.stations:
if not st.is_normal_station():
continue
if not any(lane.get_target_detectors(st)):
continue
up_station, dn_station = _find_up_and_down_stations(st)
if up_station is not None:
angle = infra.geo.angle_of_rnodes(up_station, st, dn_station)
if angle < WITHRAW_STATION_ANGLE:
logger.debug('Skip the station %s on curve (%.1f)' %
(st.station_id, angle))
continue
stations.append(st)
return stations
def make(edata):
"""
:type edata: pyticas_ncrtes.core.etypes.ESTData
"""
logger = getLogger(__name__)
logger.debug(' >>> wn_uk.make() ')
is_recovered_from_congestion = _check_directly_recovered_from_congestion(
edata)
if is_recovered_from_congestion:
edata.wn_ffs = None
edata.wn_ffs_idx = None
edata.ncrt_search_sidx = None
edata.ncrt_search_eidx = None
if edata.normal_func.is_valid() and edata.wn2_interval_sidx:
logger.debug(
' - make wet normal pattern without wn_ffs (tmp-recovered : %d - %d) '
% (edata.wn2_interval_sidx, edata.wn2_interval_eidx))
edata.make_wet_normal_pattern_without_wnffs()
else:
logger.debug(
' - cannot make wet normal pattern without wn_ffs (there is no temp-recovered area)'
)
else:
if edata.normal_func.is_valid():
wn_sidx, k_at_wn_ffs = _k_at_wn_ffs(edata, edata.wn_ffs)
edata.k_at_wn_ffs = k_at_wn_ffs
logger.debug(
' - make wet normal pattern with wn_ffs (wn_ffs=%.2f, wn_ffs_idx=%d, k_at_wn_ffs=%.2f)'
% (edata.wn_ffs, edata.wn_ffs_idx, edata.k_at_wn_ffs))
edata.make_wet_normal_pattern(edata.wn_ffs, edata.k_at_wn_ffs)
else:
logger.debug(
' - cannot make wet normal pattern with wn_ffs (no normal uk function)'
)
logger.debug(' <<< end of wn_uk.make() ')
def _may_recovered_here(target_ncrt, edata):
"""
:param target_ncrt:
:type target_ncrt: int
:param edata:
:type edata: pyticas_ncrtes.core.etypes.ESTData
"""
LOW_K = 10
CONGESTED_SPEED = 30
rth = 0.8
time_limit = setting.INTV30MIN
logger = getLogger(__name__)
own_ncrt = edata.ncrt
wn_sratios = edata.wn_sratios
if wn_sratios is None or not any(wn_sratios):
wn_sratios = np.array([_u / edata.wn_ffs for _u in edata.sus])
# low-ratio
if wn_sratios[target_ncrt] < rth:
logger.debug(' -> low ratio : %s, %s' %
(target_ncrt, edata.target_station.station_id))
return False
# check low-ratios
wn_tratios = wn_sratios[target_ncrt:own_ncrt + 1]
sus, sks = edata.sus[target_ncrt:own_ncrt +
1], edata.sks[target_ncrt:own_ncrt + 1]
losted = np.where((wn_tratios < rth) & (sus > CONGESTED_SPEED)
& (sks > LOW_K))
if len(losted[0]) > time_limit:
logger.debug(' -> time limit : %s, %s' %
(target_ncrt, edata.target_station.station_id))
return False
return True
def _adjust_with_speed(edata, target_idx):
"""
:type edata: pyticas_ncrtes.core.etypes.ESTData
:type target_idx: int
:rtype: int
"""
logger = getLogger(__name__)
sdata = data_util.smooth(edata.us, setting.SW_30MIN)
qdata = edata.qus #data_util.stepping(sdata, 2)
stick = None
qu = qdata[target_idx]
for idx in range(target_idx, 0, -1):
cu = qdata[idx]
if cu != qu:
stick = idx
break
if not stick:
return target_idx
_stick = stick
for idx in range(stick, 0, -1):
if sdata[idx] > qu:
_stick = idx + 1
else:
break
stick = _stick
# for tidx in range(stick, stick+setting.INTV15MIN):
# if sdata[tidx] >= qu:
# return tidx + 1
# never reaches to here
return stick
def _pre_process_before_determination(edata):
"""
:type edata: pyticas_ncrtes.core.etypes.ESTData
"""
logger = getLogger(__name__)
# determine FFS
if edata.normal_func and edata.normal_func.is_valid():
normal_ffs = edata.normal_func.daytime_func.get_FFS()
else:
normal_ffs = None
edata.normal_ffs = normal_ffs
# determine snowday-FFS
snowday_ffs = _snowday_ffs(edata)
edata.snowday_ffs = snowday_ffs
if not snowday_ffs:
logger.warning('Snowday FFS is not found')
# get/make normal ratios
normal_ratios = _normal_ratios(edata, snowday_ffs)
edata.normal_ratios = normal_ratios
# may-recovered-speed : FFS * 0.9
may_recovered_speed = _may_recovered_speed(edata, rth=0.9)
if not may_recovered_speed:
logger.debug(' - Cannot determine `may-recovered-speed` ')
return
edata.may_recovered_speed = may_recovered_speed
logger.debug(' - FFS : %s' % snowday_ffs)
logger.debug(' - may_recovered_speed : %s' % may_recovered_speed)
# speed and ratio threshold for candidate time intervals of free-flow
edata.ncrt_search_uth, edata.ncrt_search_rth = _uth_rth(edata)
def sections(edata_list):
"""
:type edata_list: list[pyticas_ncrtes.core.etypes.ESTData]
:rtype: list[list[pyticas_ncrtes.core.etypes.ESTData]]
"""
logger = getLogger(__name__)
snow_route_data = stations_in_same_truck_route(edata_list)
res = []
for idx, edatas in enumerate(snow_route_data):
# print('# snow_route=%d' % idx)
_sections = _divide_section(edatas)
_final_sections = _sections
# _final_sections = []
# for sidx, s in enumerate(_sections):
# _sub_sections = _divide_section_by_length(s)
# _final_sections.extend(_sub_sections)
res.extend(_final_sections)
# for sidx, s in enumerate(_final_sections):
# print('!! divide=%d' % sidx)
# for edata in s:
# print(' > ', edata.snow_route.id, ' : ', edata.target_station, ' : ', edata.target_station.lanes, edata.target_station)
for sidx, s in enumerate(res):
logger.debug('!! section=%d' % sidx)
for edata in s:
logger.debug(
' > truck_route=%s, station=%s lanes=%s, s_limit=%s label=%s '
% (edata.snow_route.id, edata.target_station.station_id,
edata.target_station.lanes, edata.target_station.s_limit,
edata.target_station.label))
# raise Exception('Here~~~')
return res
