def ResetOutputsPeriod(
self,
output_ids, # type: Union[AnyStr, List[AnyStr]]
stime, # type: Union[datetime, List[datetime]]
etime # type: Union[datetime, List[datetime]]
):
# type: (...) -> None
"""Reset the STARTTIME and ENDTIME of OUTPUTID(s)."""
if not isinstance(output_ids, list):
output_ids = [output_ids]
if not isinstance(stime, list):
stime = [stime]
if not isinstance(etime, list):
etime = [etime]
read_model = ReadModelData(self.host, self.port, self.db_name)
for idx, outputid in enumerate(output_ids):
cur_stime = stime[0]
if idx < len(stime):
cur_stime = stime[idx]
cur_etime = etime[0]
if idx < len(etime):
cur_etime = etime[idx]
cur_stime_str = cur_stime.strftime('%Y-%m-%d %H:%M:%S')
cur_etime_str = cur_etime.strftime('%Y-%m-%d %H:%M:%S')
db = read_model.maindb
db[DBTableNames.main_fileout].find_one_and_update(
{'OUTPUTID': outputid}, {
'$set': {
'STARTTIME': cur_stime_str,
'ENDTIME': cur_etime_str
}
})
def clean(self,
scenario_id=None,
calibration_id=None,
delete_scenario=False,
delete_spatial_gfs=False):
"""Clean model outputs in OUTPUT<ScenarioID>-<CalibrationID> directory and/or
GridFS files in OUTPUT collection.
Examples:
model.SetMongoClient()
model.clean()
model.UnsetMongoClient()
"""
rmtree(self.OutputDirectory, ignore_errors=True)
self.ConnectMongoDB()
read_model = ReadModelData(self.mongoclient, self.db_name)
if scenario_id is None:
scenario_id = self.scenario_id
if calibration_id is None:
calibration_id = self.calibration_id
read_model.CleanOutputGridFs(scenario_id, calibration_id)
if delete_scenario:
read_model.CleanScenariosConfiguration(scenario_id)
if delete_spatial_gfs:
read_model.CleanSpatialGridFs(scenario_id)
def OutputItems(self):
# type: (...) -> Dict[AnyStr, Union[List[AnyStr]]]
"""Read output items from database."""
if self.output_items:
return self.output_items
read_model = ReadModelData(self.host, self.port, self.db_name)
return read_model.OutputItems
def OutputIDs(self):
# type: (...) -> List[AnyStr]
"""Read output items from database."""
if self.output_ids:
return self.output_ids
read_model = ReadModelData(self.host, self.port, self.db_name)
self.output_ids, self.output_items = read_model.OutputItems()
return self.output_ids
def ReadOutletObservations(self, vars_list):
# type: (List[AnyStr]) -> (List[AnyStr], Dict[datetime, List[float]])
"""
Examples:
model.SetMongoClient()
model.ReadOutletObservations()
model.UnsetMongoClient()
"""
self.ConnectMongoDB()
self.ReadMongoDBData()
read_model = ReadModelData(self.mongoclient, self.db_name)
self.obs_vars, self.obs_value = read_model.Observation(
self.outlet_id, vars_list, self.start_time, self.end_time)
return self.obs_vars, self.obs_value
def ResetSimulationPeriod(self):
"""Update simulation time range in MongoDB [FILE_IN]."""
read_model = ReadModelData(self.host, self.port, self.db_name)
if self.simu_stime and self.simu_etime:
stime_str = self.simu_stime.strftime('%Y-%m-%d %H:%M:%S')
etime_str = self.simu_etime.strftime('%Y-%m-%d %H:%M:%S')
db = read_model.maindb
db[DBTableNames.main_filein].find_one_and_update(
{'TAG': 'STARTTIME'}, {'$set': {
'VALUE': stime_str
}})
db[DBTableNames.main_filein].find_one_and_update(
{'TAG': 'ENDTIME'}, {'$set': {
'VALUE': etime_str
}})
self.start_time, self.end_time = read_model.SimulationPeriod
def clean(self,
scenario_id=None,
calibration_id=None,
delete_scenario=False):
"""Clean model outputs in OUTPUT<ScenarioID>-<CalibrationID> directory and/or
GridFS files in OUTPUT collection.
"""
rmtree(self.OutputDirectory, ignore_errors=True)
read_model = ReadModelData(self.host, self.port, self.db_name)
if scenario_id is None:
scenario_id = self.scenario_id
if calibration_id is None:
calibration_id = self.calibration_id
read_model.CleanOutputGridFs(scenario_id, calibration_id)
if delete_scenario:
read_model.CleanScenariosConfiguration(scenario_id)
def ReadMongoDBData(self):
"""
Examples:
model.SetMongoClient()
model.ReadMongoDBData()
model.UnsetMongoClient()
"""
if self.outlet_id >= 0:
return
self.ConnectMongoDB()
read_model = ReadModelData(self.mongoclient, self.db_name)
self.outlet_id = read_model.OutletID
self.subbasin_count = read_model.SubbasinCount
self.scenario_dbname = read_model.ScenarioDBName
self.start_time, self.end_time = read_model.SimulationPeriod
self.output_ids, self.output_items = read_model.OutputItems()
def ResetSimulationPeriod(self):
"""Update simulation time range in MongoDB [FILE_IN].
Examples:
model.SetMongoClient()
model.ResetSimulationPeriod()
model.UnsetMongoClient()
"""
self.ConnectMongoDB()
read_model = ReadModelData(self.mongoclient, self.db_name)
if self.simu_stime and self.simu_etime:
stime_str = self.simu_stime.strftime('%Y-%m-%d %H:%M:%S')
etime_str = self.simu_etime.strftime('%Y-%m-%d %H:%M:%S')
db = read_model.maindb
db[DBTableNames.main_filein].find_one_and_update(
{'TAG': 'STARTTIME'}, {'$set': {
'VALUE': stime_str
}})
db[DBTableNames.main_filein].find_one_and_update(
{'TAG': 'ENDTIME'}, {'$set': {
'VALUE': etime_str
}})
self.start_time, self.end_time = read_model.SimulationPeriod
def __init__(self, cfg):
# type: (PostConfig) -> None
"""Constructor"""
self.model = MainSEIMS(args_dict=cfg.model_cfg.ConfigDict)
self.ws = self.model.OutputDirectory
if not FileClass.is_dir_exists(self.ws):
raise ValueError('The output directory %s is not existed!' %
self.ws)
self.plot_vars = cfg.plot_vars
self.plot_cfg = cfg.plot_cfg # type: PlotConfig
# UTCTIME, calibration period
self.stime = cfg.cali_stime
self.etime = cfg.cali_etime
self.subbsnID = cfg.plt_subbsnid
# validation period
self.vali_stime = cfg.vali_stime
self.vali_etime = cfg.vali_etime
# Read model data from MongoDB, the time period of simulation is read from FILE_IN.
mongoclient = ConnectMongoDB(self.model.host,
self.model.port).get_conn()
self.readData = ReadModelData(mongoclient, self.model.db_name)
self.mode = self.readData.Mode
self.interval = self.readData.Interval
# check start and end time of calibration
st, et = self.readData.SimulationPeriod
self.plot_validation = True
if st > self.stime:
self.stime = st
if et < self.etime:
self.etime = et
if st > self.etime > self.stime:
self.stime = st
self.etime = et
# in this circumstance, no validation should be calculated.
self.vali_stime = None
self.vali_etime = None
self.plot_validation = False
# check validation time period
if self.vali_stime and self.vali_etime:
if self.vali_stime >= self.vali_etime or st > self.vali_etime > self.vali_stime \
or self.vali_stime >= et:
self.vali_stime = None
self.vali_etime = None
self.plot_validation = False
elif st > self.vali_stime:
self.vali_stime = st
elif et < self.vali_etime:
self.vali_etime = et
else:
self.plot_validation = False
# Set start time and end time of both calibration and validation periods
start = self.stime
end = self.etime
if self.plot_validation:
start = self.stime if self.stime < self.vali_stime else self.vali_stime
end = self.etime if self.etime > self.vali_etime else self.vali_etime
self.outletid = self.readData.OutletID
# read precipitation
self.pcp_date_value = self.readData.Precipitation(
self.subbsnID, start, end)
# read simulated data and update the available variables
self.plot_vars, self.sim_data_dict = read_simulation_from_txt(
self.ws, self.plot_vars, self.outletid, start, end)
self.sim_data_value = list(
) # type: List[List[Union[datetime, float]]]
for d, vs in self.sim_data_dict.items():
self.sim_data_value.append([d] + vs[:])
# reset start time and end time
if len(self.sim_data_value) == 0:
raise RuntimeError(
'No available simulate data, please check the start and end time!'
)
# read observation data from MongoDB
self.obs_vars, self.obs_data_dict = self.readData.Observation(
self.subbsnID, self.plot_vars, start, end)
# Calibration period
self.sim_obs_dict = match_simulation_observation(self.plot_vars,
self.sim_data_dict,
self.obs_vars,
self.obs_data_dict,
start_time=self.stime,
end_time=self.etime)
calculate_statistics(self.sim_obs_dict)
# Validation period if existed
self.vali_sim_obs_dict = dict()
if self.plot_validation:
self.vali_sim_obs_dict = match_simulation_observation(
self.plot_vars,
self.sim_data_dict,
self.obs_vars,
self.obs_data_dict,
start_time=self.vali_stime,
end_time=self.vali_etime)
calculate_statistics(self.vali_sim_obs_dict)
def ReadOutletObservations(self, vars_list):
# type: (List[AnyStr]) -> (List[AnyStr], Dict[datetime, List[float]])
read_model = ReadModelData(self.host, self.port, self.db_name)
self.obs_vars, self.obs_value = read_model.Observation(
self.outlet_id, vars_list, self.start_time, self.end_time)
return self.obs_vars, self.obs_value
def SimulatedPeriod(self):
# type: (...) -> (datetime, datetime)
read_model = ReadModelData(self.host, self.port, self.db_name)
return read_model.SimulationPeriod
def ScenarioDBName(self):
# type: (...) -> AnyStr
read_model = ReadModelData(self.host, self.port, self.db_name)
return read_model.ScenarioDBName
def SubbasinCount(self):
# type: (...) -> int
read_model = ReadModelData(self.host, self.port, self.db_name)
return read_model.SubbasinCount
def OutletID(self):
# type: (...) -> int
read_model = ReadModelData(self.host, self.port, self.db_name)
return read_model.OutletID
