def __check_if_all_value_are_numbers(self, wf_controlled_data):
"""
Check if all the values in the forecast are numbers.
"""
for sElement in wf_controlled_data.get_matrix_col_list():
if sElement.find('TIME') > 0:
continue
npElement = wf_controlled_data.get_matrix_col(sElement)
# In the case of 'CC', only return an error if both SF and IR
# are not given
if sElement is 'CC':
if metro_config.get_value('SF') and metro_config.get_value('IR'):
continue
for fElement in npElement:
if fpconst.isNaN(fElement):
if wf_controlled_data.is_standardCol(sElement):
sMessage = _("Value in forecast file must be valid.\n") \
+ _("A value for the element <%s> is invalid")\
% (sElement.lower())+\
_(" in the file\n'%s'") %\
(metro_config.get_value(\
"FILE_FORECAST_IN_FILENAME"))
raise metro_error.Metro_data_error(sMessage)
else:
sMessage = _("A value for the extended element <%s> is invalid") % (sElement.lower())+\
_(" in the file\n'%s'") % (metro_config.get_value("FILE_FORECAST_IN_FILENAME"))
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
def start(self):
Metro_read.start(self)
if metro_config.key_exist('FILE_STATION_FILENAME'):
sFilename = metro_config.get_value('FILE_STATION_FILENAME')
else:
sFilename = ""
if sFilename != "":
try:
sFile_content = self._read_input_data(sFilename)
except IOError:
sError_message = _("METRo need a valid station file.")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
else:
# Create and add infdata
infdata_station = metro_infdata.Metro_infdata(
'STATION', metro_infdata.DATATYPE_METRO_DATA)
infdata_station.set_input_information(sFile_content)
self.add_infdata(infdata_station)
if metro_config.get_value('SUNSHADOW'):
infdata_horizon = metro_infdata.Metro_infdata(
'HORIZON', metro_infdata.DATATYPE_METRO_DATA)
self.add_infdata(infdata_horizon)
else:
sError_message = _("METRo need a station file, please use the ") +\
_("option: '--input-station'")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
def __round_roadcast_header( self, roadcast):
if 'VERTICAL_LEVELS' in roadcast.get_header():
# Get the default value for the accurary of "float" of the roadcast
iDefault_precision = \
metro_config.get_value('DEFAULT_ROADCAST_PREDICTION_PRECISION')
dData_types = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_types.update(dExtended_data_type)
sCurrent_data_type = 'VERTICAL_LEVELS'
# get precision
if 'CHILD' in dData_types[sCurrent_data_type]:
if len(dData_types[sCurrent_data_type]['CHILD']) == 1 and \
dData_types[sCurrent_data_type]['CHILD'][0]['DATA_TYPE'] == 'REAL':
# If the accuracy have been specified: use it.
# Otherwhise use the default value for the roadcast.
if 'PRECISION' in dData_types[sCurrent_data_type]['CHILD'][0]:
iPrecision = dData_types[sCurrent_data_type]['CHILD'][0]['PRECISION']
else:
iPrecision = iDefault_precision
lLevels = roadcast.get_header_value('VERTICAL_LEVELS')
lRounded = [round(x,iPrecision) for x in lLevels]
roadcast.set_header_value('VERTICAL_LEVELS',lRounded)
def create_node_tree_from_dict(domDoc, nodeParent, lDefs, dWriteHandlers,
dData):
# Retrieve the informations on the data types
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
for dDef in lDefs:
# Retrieve the name and the item type
sTag = dDef['NAME']
sXml_tag = dDef['XML_TAG']
sData_type_name = dDef['DATA_TYPE']
if dData_type[sData_type_name].has_key('CHILD'):
# create the node containing a list of "sub-node"
lChildList = dData_type[sData_type_name]['CHILD']
nodeData = dWriteHandlers[sData_type_name](sXml_tag, lChildList,
dData[sTag],
dWriteHandlers)
else:
# create the node
nodeData = dWriteHandlers[sData_type_name](sXml_tag, dData[sTag])
append_child(nodeParent, nodeData)
def __validate_optional_args_forecast(self, forecast_data):
"""
In the case the user asked to use infra-red and/or solar flux
as input, check if the values are really in the input files.
"""
# Check for solar-flux
if metro_config.get_value('SF') and \
'SF' not in forecast_data.lMatrix_col_name:
sInputAtmosphericForecast = metro_config.\
get_value('FILE_FORECAST_IN_FILENAME')
sMessage = _("The option '--use-solarflux-forecast' was used\n") +\
_("but the information was not in the atmospheric\n") +\
_("forecast file. Please check for the tag '<sf>'\n") +\
_("in the file: %s") % (sInputAtmosphericForecast)
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP, sMessage)
# Check for infra-red
if metro_config.get_value('IR') and \
'IR' not in forecast_data.lMatrix_col_name:
sInputAtmosphericForecast = metro_config.\
get_value('FILE_FORECAST_IN_FILENAME')
sMessage = _("The option '--use-infrared-forecast' was used\n") +\
_("but the information was not in the atmospheric\n") +\
_("forecast file. Please check for the tag '<ir>'\n") +\
_("in the file: %s") % (sInputAtmosphericForecast)
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP, sMessage)
def get_handler(sHandlerType, dDefData, dAllDefData=None):
if dAllDefData == None:
# Retrieve the informations about the data types
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dAllDefData = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
sTag = dDefData['NAME']
sXml_tag = dDefData['XML_TAG']
sData_type_name = dDefData['DATA_TYPE']
if sData_type_name not in dAllDefData.keys():
sMessage = _("Invalid data_type: (%s) for the following ") \
% (sData_type_name) +\
_("tag:(%s). Default data type will be used.") \
% (sTag)
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING, sMessage)
sData_type_name = 'DEFAULT'
# The data type needs the call of a function to create the node
sHandler = dAllDefData[sData_type_name][sHandlerType]
return sHandler
def __round_roadcast_header( self, roadcast):
if 'VERTICAL_LEVELS' in roadcast.get_header():
# Get the default value for the accurary of "float" of the roadcast
iDefault_precision = \
metro_config.get_value('DEFAULT_ROADCAST_PREDICTION_PRECISION')
dData_types = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_types.update(dExtended_data_type)
sCurrent_data_type = 'VERTICAL_LEVELS'
# get precision
if 'CHILD' in dData_types[sCurrent_data_type]:
if len(dData_types[sCurrent_data_type]['CHILD']) == 1 and \
dData_types[sCurrent_data_type]['CHILD'][0]['DATA_TYPE'] == 'REAL':
# If the accuracy have been specified: use it.
# Otherwhise use the default value for the roadcast.
if 'PRECISION' in dData_types[sCurrent_data_type]['CHILD'][0]:
iPrecision = dData_types[sCurrent_data_type]['CHILD'][0]['PRECISION']
else:
iPrecision = iDefault_precision
lLevels = roadcast.get_header_value('VERTICAL_LEVELS')
lRounded = [round(x,iPrecision) for x in lLevels]
roadcast.set_header_value('VERTICAL_LEVELS',lRounded)
def validate_xml_file_def(dConf):
# file definition to check
lXML_files = [
'XML_FORECAST_HEADER_STANDARD_ITEMS',
'XML_FORECAST_HEADER_EXTENDED_ITEMS',
'XML_FORECAST_PREDICTION_STANDARD_ITEMS',
'XML_FORECAST_PREDICTION_EXTENDED_ITEMS',
'XML_OBSERVATION_HEADER_STANDARD_ITEMS',
'XML_OBSERVATION_HEADER_EXTENDED_ITEMS',
'XML_OBSERVATION_MEASURE_STANDARD_ITEMS',
'XML_OBSERVATION_MEASURE_EXTENDED_ITEMS',
'XML_STATION_HEADER_STANDARD_ITEMS',
'XML_STATION_HEADER_EXTENDED_ITEMS',
'XML_STATION_ROADLAYER_STANDARD_ITEMS',
'XML_STATION_ROADLAYER_EXTENDED_ITEMS',
'XML_ROADCAST_HEADER_STANDARD_ITEMS',
'XML_ROADCAST_HEADER_EXTENDED_ITEMS',
'XML_ROADCAST_PREDICTION_STANDARD_ITEMS',
'XML_ROADCAST_PREDICTION_EXTENDED_ITEMS',
]
# extract all data type
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dAll_data_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
for sXML_file in lXML_files:
iFrom = dConf[sXML_file]['FROM']
lXML_items = dConf[sXML_file]['VALUE']
validate_xml_itemlist_def(sXML_file, iFrom, lXML_items, dAll_data_type)
def __check_if_all_value_are_numbers(self, wf_controlled_data):
"""
Check if all the values in the forecast are numbers.
"""
for sElement in wf_controlled_data.get_matrix_col_list():
if sElement.find('TIME') > 0:
continue
npElement = wf_controlled_data.get_matrix_col(sElement)
# In the case of 'CC', only return an error if both SF and IR
# are not given
if sElement is 'CC':
if metro_config.get_value('SF') and metro_config.get_value(
'IR'):
continue
for fElement in npElement:
if fpconst.isNaN(fElement):
if wf_controlled_data.is_standardCol(sElement):
sMessage = _("Value in forecast file must be valid.\n") \
+ _("A value for the element <%s> is invalid")\
% (sElement.lower())+\
_(" in the file\n'%s'") %\
(metro_config.get_value(\
"FILE_FORECAST_IN_FILENAME"))
raise metro_error.Metro_data_error(sMessage)
else:
sMessage = _("A value for the extended element <%s> is invalid") % (sElement.lower())+\
_(" in the file\n'%s'") % (metro_config.get_value("FILE_FORECAST_IN_FILENAME"))
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
def start(self):
Metro_read.start(self)
if metro_config.key_exist('FILE_STATION_FILENAME'):
sFilename = metro_config.get_value('FILE_STATION_FILENAME')
else:
sFilename = ""
if sFilename != "":
try:
sFile_content = self._read_input_data(sFilename)
except IOError:
sError_message = _("METRo need a valid station file.")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
else:
# Create and add infdata
infdata_station = metro_infdata.Metro_infdata(
'STATION', metro_infdata.DATATYPE_METRO_DATA)
infdata_station.set_input_information(sFile_content)
self.add_infdata(infdata_station)
if metro_config.get_value('SUNSHADOW'):
infdata_horizon = metro_infdata.Metro_infdata(
'HORIZON', metro_infdata.DATATYPE_METRO_DATA)
self.add_infdata(infdata_horizon)
else:
sError_message = _("METRo need a station file, please use the ") +\
_("option: '--input-station'")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
def __validate_optional_args_forecast(self, forecast_data):
"""
In the case the user asked to use infra-red and/or solar flux
as input, check if the values are really in the input files.
"""
# Check for solar-flux
if metro_config.get_value('SF') and \
'SF' not in forecast_data.lMatrix_col_name:
sInputAtmosphericForecast = metro_config.\
get_value('FILE_FORECAST_IN_FILENAME')
sMessage = _("The option '--use-solarflux-forecast' was used\n") +\
_("but the information was not in the atmospheric\n") +\
_("forecast file. Please check for the tag '<sf>'\n") +\
_("in the file: %s") % (sInputAtmosphericForecast)
metro_logger.print_message(
metro_logger.LOGGER_MSG_STOP, sMessage)
# Check for infra-red
if metro_config.get_value('IR') and \
'IR' not in forecast_data.lMatrix_col_name:
sInputAtmosphericForecast = metro_config.\
get_value('FILE_FORECAST_IN_FILENAME')
sMessage = _("The option '--use-infrared-forecast' was used\n") +\
_("but the information was not in the atmospheric\n") +\
_("forecast file. Please check for the tag '<ir>'\n") +\
_("in the file: %s") % (sInputAtmosphericForecast)
metro_logger.print_message(
metro_logger.LOGGER_MSG_STOP, sMessage)
def get_handler(sHandlerType, dDefData, dAllDefData=None):
if dAllDefData == None:
# Retrieve the informations about the data types
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dAllDefData = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
sTag = dDefData['NAME']
sXml_tag = dDefData['XML_TAG']
sData_type_name = dDefData['DATA_TYPE']
if sData_type_name not in dAllDefData.keys():
sMessage = _("Invalid data_type: (%s) for the following ") \
% (sData_type_name) +\
_("tag:(%s). Default data type will be used.") \
% (sTag)
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
sMessage)
sData_type_name = 'DEFAULT'
# The data type needs the call of a function to create the node
sHandler = dAllDefData[sData_type_name][sHandlerType]
return sHandler
def __set_first_roadcast_date(self, observation_data, roadcast_data):
"""
Name: ___set_first_roadcast_date
Parameters: Observation and roadcast
Description: If the date of the first roadcast is not specified in the input
(command line or config file), set it to first round 20 minutes after
the last observation.
Author: Miguel Tremblay
Date: March 5th 2007
"""
# Check if the value is given as an argument
if metro_config.get_value('INIT_ROADCAST_START_DATE') != "":
# Set the xml header value
controlled_roadcast = roadcast_data.get_subsampled_data()
controlled_roadcast.set_header_value('FIRST_ROADCAST',\
metro_config.get_value('INIT_ROADCAST_START_DATE'))
return 0
else : # if value of INIT_ROADCAST_START_DATE is not given, fetch the first
# round 20 minutes.
naOT = observation_data.get_matrix_col('OBSERVATION_TIME')
fLast_observation_date = naOT[len(naOT)-1]
sLast_observation_date = metro_date.seconds2iso8601(fLast_observation_date)
# Fetch the first 20 minutes value.
iNb_timesteps = roadcast_data.get_attribute('FORECAST_NB_TIMESTEPS')
nSecondsForOutput = metro_constant.nMinutesForOutput*60
lTimeStep = roadcast_data.get_controlled_data().get_matrix_col('HH')
for i in range(0, iNb_timesteps):
fCurrentTime = lTimeStep[i]*3600
# Forecast at every 20 minutes, i.e. 1200 seconds
# if current time is a 20 minute interval
# and roadcast time is >= roadcast start date
if round(fCurrentTime)%nSecondsForOutput == 0:
sLast_observation = metro_config.\
get_value('DATA_ATTRIBUTE_LAST_OBSERVATION')
fLast_observation = metro_date.parse_date_string(sLast_observation)
sStart_date = metro_date.seconds2iso8601(fLast_observation + \
(i+1)*\
metro_constant.fTimeStep)
metro_config.set_value('INIT_ROADCAST_START_DATE', sStart_date)
sMessage = _("Roadcast start date set to: ''%s'") % (sStart_date)
metro_logger.print_message(metro_logger.LOGGER_MSG_INFORMATIVE,\
sMessage)
# Set the xml header value
controlled_roadcast = roadcast_data.get_subsampled_data()
controlled_roadcast.set_header_value('FIRST_ROADCAST', sStart_date)
return i
# Something bad hapened.
sMessage = _("Unable to determine the first time of roadcast!")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
def __round_roadcast_data( self, roadcast_data):
# Get the matrix columns definition
lStandard_roadcast = metro_config.get_value( \
'XML_ROADCAST_PREDICTION_STANDARD_ITEMS')
lExtended_roadcast = metro_config.get_value( \
'XML_ROADCAST_PREDICTION_EXTENDED_ITEMS')
lRoadcast_items = lStandard_roadcast + lExtended_roadcast
# Get the default value for the accurary of "float" of the roadcast
iDefault_precision = \
metro_config.get_value('DEFAULT_ROADCAST_PREDICTION_PRECISION')
dData_types = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_types.update(dExtended_data_type)
# Process of each column of roadcast
iItem_id = 0
for dRoadcast_item in lRoadcast_items:
sCurrent_data_type = dRoadcast_item['DATA_TYPE']
# If this column contains float data
if dRoadcast_item['DATA_TYPE'] == 'REAL':
# If the accuracy have been specified: use it.
# Otherwhise use the default value for the roadcast.
if 'PRECISION' in dRoadcast_item:
iPrecision = dRoadcast_item['PRECISION']
else:
iPrecision = iDefault_precision
# Perform the round operation
npCol = roadcast_data.get_matrix_col(dRoadcast_item['NAME'])
npCol = numpy.around(npCol,iPrecision)
roadcast_data.set_matrix_col(dRoadcast_item['NAME'], npCol)
# If this column as only one child who is a REAL: its probably a list of float
elif 'CHILD' in dData_types[sCurrent_data_type]:
if len(dData_types[sCurrent_data_type]['CHILD']) == 1 and \
dData_types[sCurrent_data_type]['CHILD'][0]['DATA_TYPE'] == 'REAL':
# If the accuracy have been specified: use it.
# Otherwhise use the default value for the roadcast.
if 'PRECISION' in dData_types[sCurrent_data_type]['CHILD'][0]:
iPrecision = dData_types[sCurrent_data_type]['CHILD'][0]['PRECISION']
else:
iPrecision = iDefault_precision
npCol = roadcast_data.get_matrix_col(dRoadcast_item['NAME'])
npCol = numpy.around(npCol,iPrecision)
roadcast_data.set_matrix_multiCol(dRoadcast_item['NAME'], npCol)
def __round_roadcast_data( self, roadcast_data):
# Get the matrix columns definition
lStandard_roadcast = metro_config.get_value( \
'XML_ROADCAST_PREDICTION_STANDARD_ITEMS')
lExtended_roadcast = metro_config.get_value( \
'XML_ROADCAST_PREDICTION_EXTENDED_ITEMS')
lRoadcast_items = lStandard_roadcast + lExtended_roadcast
# Get the default value for the accurary of "float" of the roadcast
iDefault_precision = \
metro_config.get_value('DEFAULT_ROADCAST_PREDICTION_PRECISION')
dData_types = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_types.update(dExtended_data_type)
# Process of each column of roadcast
iItem_id = 0
for dRoadcast_item in lRoadcast_items:
sCurrent_data_type = dRoadcast_item['DATA_TYPE']
# If this column contains float data
if dRoadcast_item['DATA_TYPE'] == 'REAL':
# If the accuracy have been specified: use it.
# Otherwhise use the default value for the roadcast.
if 'PRECISION' in dRoadcast_item:
iPrecision = dRoadcast_item['PRECISION']
else:
iPrecision = iDefault_precision
# Perform the round operation
npCol = roadcast_data.get_matrix_col(dRoadcast_item['NAME'])
npCol = numpy.around(npCol,iPrecision)
roadcast_data.set_matrix_col(dRoadcast_item['NAME'], npCol)
# If this column as only one child who is a REAL: its probably a list of float
elif 'CHILD' in dData_types[sCurrent_data_type]:
if len(dData_types[sCurrent_data_type]['CHILD']) == 1 and \
dData_types[sCurrent_data_type]['CHILD'][0]['DATA_TYPE'] == 'REAL':
# If the accuracy have been specified: use it.
# Otherwhise use the default value for the roadcast.
if 'PRECISION' in dData_types[sCurrent_data_type]['CHILD'][0]:
iPrecision = dData_types[sCurrent_data_type]['CHILD'][0]['PRECISION']
else:
iPrecision = iDefault_precision
npCol = roadcast_data.get_matrix_col(dRoadcast_item['NAME'])
npCol = numpy.around(npCol,iPrecision)
roadcast_data.set_matrix_multiCol(dRoadcast_item['NAME'], npCol)
def init( ):
"""
Name: init
Parameters: none
Return: none
Description: Logger verbosity level initialization.
"""
global iLogger_verbose_level
global bLogger_shell_display
global sLogger_filename
global fLogger_file
global bIs_initialised
# Pre-initialization in order to not log logger init...
iLogger_verbose_level = LOGGER_VERBOSE_LEVEL_NOLOG
bLogger_shell_display = False
sMessage = _("Starting METRo logger")
print_init_message(LOGGER_INIT_MESSAGE,sMessage)
# Retrieve configuration values
sTmp_logger_filename = metro_config.get_value("FILE_LOGGER_FILENAME")
iTmp_logger_verbose_level = \
metro_config.get_value("INIT_LOGGER_VERBOSE_LEVEL")
bTmp_logger_shell_display = \
metro_config.get_value("INIT_LOGGER_SHELL_DISPLAY")
# Initialization
sLogger_filename = sTmp_logger_filename
iLogger_verbose_level = iTmp_logger_verbose_level
bLogger_shell_display = bTmp_logger_shell_display
# Open log file
try:
fLogger_file = open(sLogger_filename,'a')
except IOError:
fLogger_file = None
sError_message = _("can't open/create logger file:'%s'") \
% (sLogger_filename)
print_init_message(LOGGER_INIT_ERROR,
sError_message)
else:
# Log header writing
write_log_header(fLogger_file, iLogger_verbose_level)
sSuccess_message = _("METRo logger started, log file:'%s'") \
% (sLogger_filename)
print_init_message(LOGGER_INIT_SUCCESS,
sSuccess_message)
bIs_initialised = True
def create_node_tree_from_matrix(domDoc, nodeParent, sPrediction_xpath, lDefs,
dWriteHandlers, metro_data_object, npMatrix):
"""
Each prediction will be contained in a node that will have the name
given by sPrediction_xpath.
"""
# Retrieve the informations about the data types
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
for npData in npMatrix:
# If needed, creation of a node to contain the prediction
if sPrediction_xpath != None and sPrediction_xpath != "":
nodePrediction = mkdir_xpath(domDoc, nodeParent, sPrediction_xpath)
else:
nodePrediction = nodeParent
for dDef in lDefs:
# Get the name and the type of the item
sTag = dDef['NAME']
sXml_tag = dDef['XML_TAG']
sData_type_name = dDef['DATA_TYPE']
# Extraction of the data from the matrix
lIndexList = metro_data_object.index_of_matrix_col(sTag)
if not metro_data_object.is_multi_col(sTag):
# single col
val = npData[lIndexList[0]]
else:
# multi col
# FFTODO good candidate for optimisation
val = []
for i in lIndexList:
val.append(npData[i])
if dData_type[sData_type_name].has_key('CHILD'):
# create the node containing a list of "sub-node"
lChildList = dData_type[sData_type_name]['CHILD']
nodeData = dWriteHandlers[sData_type_name](sXml_tag,
lChildList, val,
dWriteHandlers)
else:
# create the node
nodeData = dWriteHandlers[sData_type_name](sXml_tag, val)
append_child(nodePrediction, nodeData)
def init( ):
"""
Name: init
Parameters: none
Return: none
Description: Logger verbosity level initialization.
"""
global iLogger_verbose_level
global bLogger_shell_display
global sLogger_filename
global fLogger_file
global bIs_initialised
# Pre-initialization in order to not log logger init...
iLogger_verbose_level = LOGGER_VERBOSE_LEVEL_NOLOG
bLogger_shell_display = False
sMessage = _("Starting METRo logger")
print_init_message(LOGGER_INIT_MESSAGE,sMessage)
# Retrieve configuration values
sTmp_logger_filename = metro_config.get_value("FILE_LOGGER_FILENAME")
iTmp_logger_verbose_level = \
metro_config.get_value("INIT_LOGGER_VERBOSE_LEVEL")
bTmp_logger_shell_display = \
metro_config.get_value("INIT_LOGGER_SHELL_DISPLAY")
# Initialization
sLogger_filename = sTmp_logger_filename
iLogger_verbose_level = iTmp_logger_verbose_level
bLogger_shell_display = bTmp_logger_shell_display
# Open log file
try:
fLogger_file = open(sLogger_filename,'a')
except IOError:
fLogger_file = None
sError_message = _("can't open/create logger file:'%s'") \
% (sLogger_filename)
print_init_message(LOGGER_INIT_ERROR,
sError_message)
else:
# Log header writing
write_log_header(fLogger_file, iLogger_verbose_level)
sSuccess_message = _("METRo logger started, log file:'%s'") \
% (sLogger_filename)
print_init_message(LOGGER_INIT_SUCCESS,
sSuccess_message)
bIs_initialised = True
def __set_sf(self, wf_controlled_data, wf_interpolated_data):
"""
Set the theoretical solar flux.
Parameters:
wf_controlled_data (metro_data) : controlled data. Read-only
"""
npTime = wf_controlled_data.get_matrix_col('Time')
# Only interpolate if SF is given
if metro_config.get_value('SF'):
npSF = wf_controlled_data.get_matrix_col('SF')
npSF2 = metro_util.interpolate(npTime, npSF)
if ((self.infdata_exist('HORIZON')) and (self.npAzim != None)):
npFT2 = wf_interpolated_data.get_matrix_col('FORECAST_TIME')
tDate2 = [time.gmtime(x) for x in npFT2]
sunshadw_method = metro_config.get_value('SUNSHADOW_METHOD')
npSF2 = metro_preprocess_sunshadw.\
get_corrected_solar_flux(tDate2, npSF2, \
self.fLat, self.fLon,\
zip(self.npAzim, self.npElev),\
m=sunshadw_method)
wf_interpolated_data.append_matrix_col('SF', npSF2)
return
# Get data
npCloudOctal = wf_controlled_data.get_matrix_col('CC')
npTimeHour = wf_controlled_data.get_matrix_col('Hour')
npForecastedTime = wf_controlled_data.\
get_matrix_col('FORECAST_TIME')
fStartForecastTime = npForecastedTime[0]
# Get solar fluxes for this cloud cover for this specific day
npSF = metro_physics.get_sf(npCloudOctal, npTimeHour, \
npForecastedTime,\
self.fSunrise, self.fSunset,\
self.fLat, self.fLon)
npSF2 = metro_util.interpolate(npTime, npSF)
if ((self.infdata_exist('HORIZON')) and (self.npAzim != None)):
npFT2 = wf_interpolated_data.get_matrix_col('FORECAST_TIME')
tDate2 = [time.gmtime(x) for x in npFT2]
sunshadw_method = metro_config.get_value('SUNSHADOW_METHOD')
npSF2 = metro_preprocess_sunshadw.\
get_corrected_solar_flux(tDate2, npSF2, \
self.fLat, self.fLon,\
zip(self.npAzim, self.npElev),\
m=sunshadw_method)
wf_controlled_data.append_matrix_col('SF', npSF)
wf_interpolated_data.append_matrix_col('SF', npSF2)
def __set_sf(self, wf_controlled_data, wf_interpolated_data):
"""
Set the theoretical solar flux.
Parameters:
wf_controlled_data (metro_data) : controlled data. Read-only
"""
npTime = wf_controlled_data.get_matrix_col('Time')
# Only interpolate if SF is given
if metro_config.get_value('SF'):
npSF = wf_controlled_data.get_matrix_col('SF')
npSF2 = metro_util.interpolate(npTime, npSF)
if ((self.infdata_exist('HORIZON')) and (self.npAzim != None)):
npFT2 = wf_interpolated_data.get_matrix_col('FORECAST_TIME')
tDate2 = [time.gmtime(x) for x in npFT2]
sunshadw_method = metro_config.get_value('SUNSHADOW_METHOD')
npSF2 = metro_preprocess_sunshadw.\
get_corrected_solar_flux(tDate2, npSF2, \
self.fLat, self.fLon,\
zip(self.npAzim, self.npElev),\
m=sunshadw_method)
wf_interpolated_data.append_matrix_col('SF', npSF2)
return
# Get data
npCloudOctal = wf_controlled_data.get_matrix_col('CC')
npTimeHour = wf_controlled_data.get_matrix_col('Hour')
npForecastedTime = wf_controlled_data.\
get_matrix_col('FORECAST_TIME')
fStartForecastTime =npForecastedTime [0]
# Get solar fluxes for this cloud cover for this specific day
npSF = metro_physics.get_sf(npCloudOctal, npTimeHour, \
npForecastedTime,\
self.fSunrise, self.fSunset,\
self.fLat, self.fLon)
npSF2 = metro_util.interpolate(npTime, npSF)
if ((self.infdata_exist('HORIZON')) and (self.npAzim != None)):
npFT2 = wf_interpolated_data.get_matrix_col('FORECAST_TIME')
tDate2 = [time.gmtime(x) for x in npFT2]
sunshadw_method = metro_config.get_value('SUNSHADOW_METHOD')
npSF2 = metro_preprocess_sunshadw.\
get_corrected_solar_flux(tDate2, npSF2, \
self.fLat, self.fLon,\
zip(self.npAzim, self.npElev),\
m=sunshadw_method)
wf_controlled_data.append_matrix_col('SF', npSF)
wf_interpolated_data.append_matrix_col('SF', npSF2)
def create_node_tree_from_matrix( domDoc, nodeParent, sPrediction_xpath,
lDefs, dWriteHandlers, metro_data_object, npMatrix ):
"""
Each prediction will be contained in a node that will have the name
given by sPrediction_xpath.
"""
# Retrieve the informations about the data types
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
for npData in npMatrix:
# If needed, creation of a node to contain the prediction
if sPrediction_xpath != None and sPrediction_xpath != "":
nodePrediction = mkdir_xpath(domDoc, nodeParent, sPrediction_xpath)
else:
nodePrediction = nodeParent
for dDef in lDefs:
# Get the name and the type of the item
sTag = dDef['NAME']
sXml_tag = dDef['XML_TAG']
sData_type_name = dDef['DATA_TYPE']
# Extraction of the data from the matrix
lIndexList = metro_data_object.index_of_matrix_col(sTag)
if not metro_data_object.is_multi_col(sTag):
# single col
val = npData[lIndexList[0]]
else:
# multi col
# FFTODO good candidate for optimisation
val = []
for i in lIndexList:
val.append(npData[i])
if dData_type[sData_type_name].has_key('CHILD'):
# create the node containing a list of "sub-node"
lChildList = dData_type[sData_type_name]['CHILD']
nodeData = dWriteHandlers[sData_type_name](sXml_tag,lChildList,val,dWriteHandlers)
else:
# create the node
nodeData = dWriteHandlers[sData_type_name](sXml_tag,val)
append_child(nodePrediction, nodeData)
def extract_data(lDefs, dReadHandlers, nodeItems):
"""
Name: extract_data
Arguments: [I] lDefs: list of dictionary containing the
definition of XML element in metro_config.py
[I] dReadHandlers: dictionnay of read handler.
key = data type name (ex: INTEGER),
value = handler (ex: toolbox.metro_dom2metro_handler.read_integer)
[I] nodeItems: fecth the elements in theses nodes
Output: lData :: list of values, one per definition in lDefs.
Description: Extract the data from one node containing more nodes.
"""
lData = []
# Retrieve the informations about the data type
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
# For each definitions of item
for dDef in lDefs:
# Get the name and the type of the item
sTag = dDef['XML_TAG']
sData_type_name = dDef['DATA_TYPE']
if dData_type[sData_type_name].has_key('CHILD'):
# extract the data containing a list of "sub-data"
nodeTmp = metro_xml_lib.xpath(nodeItems, sTag)
lChildList = dData_type[sData_type_name]['CHILD']
data = dReadHandlers[sData_type_name](lChildList, nodeTmp,
dReadHandlers)
else:
# extract the data
data = dReadHandlers[sData_type_name](sTag, nodeItems)
lData.append(data)
# If there is only one definition of data (lDefs), it is an "array".
# In this case, we must extract the "array" from the list
# [[1,2,3,...,N]] ==> [1,2,3,...,N]
if len(lDefs) == 1:
if lData:
lData = lData[0]
return lData
def extract_data(lDefs, dReadHandlers, nodeItems):
"""
Name: extract_data
Arguments: [I] lDefs: list of dictionary containing the
definition of XML element in metro_config.py
[I] dReadHandlers: dictionnay of read handler.
key = data type name (ex: INTEGER),
value = handler (ex: toolbox.metro_dom2metro_handler.read_integer)
[I] nodeItems: fecth the elements in theses nodes
Output: lData :: list of values, one per definition in lDefs.
Description: Extract the data from one node containing more nodes.
"""
lData = []
# Retrieve the informations about the data type
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
# For each definitions of item
for dDef in lDefs:
# Get the name and the type of the item
sTag = dDef['XML_TAG']
sData_type_name = dDef['DATA_TYPE']
if dData_type[sData_type_name].has_key('CHILD'):
# extract the data containing a list of "sub-data"
nodeTmp = metro_xml_lib.xpath(nodeItems,sTag)
lChildList = dData_type[sData_type_name]['CHILD']
data = dReadHandlers[sData_type_name](lChildList,nodeTmp,dReadHandlers)
else:
# extract the data
data = dReadHandlers[sData_type_name](sTag,nodeItems)
lData.append(data)
# If there is only one definition of data (lDefs), it is an "array".
# In this case, we must extract the "array" from the list
# [[1,2,3,...,N]] ==> [1,2,3,...,N]
if len(lDefs) == 1:
if lData:
lData = lData[0]
return lData
def __set_cc(self, wf_controlled_data, wf_interpolated_data):
"""
In the case that SF and IR are given, put the values of CC to -1.
Parameters:
wf_controlled_data (metro_data) : controlled data. Read-only
"""
if metro_config.get_value('SF') and metro_config.get_value('IR'):
npTime = wf_controlled_data.get_matrix_col('Time')
npCloudOctal = wf_controlled_data.get_matrix_col('CC')
nLength = len(npCloudOctal)
npCloud = numpy.ones(nLength) * (-1)
npCloud2 = metro_util.interpolate(npTime, npCloud)
wf_controlled_data.set_matrix_col('CC', npCloud)
wf_interpolated_data.set_matrix_col('CC', npCloud2)
def start( self ):
Metro_module.start(self)
pForecast = self.get_infdata_reference('FORECAST')
forecast_data = pForecast.get_data_collection()
pObservation = self.get_infdata_reference('OBSERVATION')
observation_data = pObservation.get_data_collection()
pStation = self.get_infdata_reference('STATION')
station_data = pStation.get_data()
if metro_config.get_value('T_BYPASS_CORE') == False:
self.__send_data_to_metro_core(forecast_data,
observation_data,
station_data )
roadcast_data = self.__create_roadcast_collection(forecast_data,
observation_data,
station_data)
else:
roadcast_data = None
metro_logger.print_message(
metro_logger.LOGGER_MSG_INFORMATIVE,
_("Bypassing METRo core, roadcast not created."))
pForecast.set_data_collection(forecast_data)
pObservation.set_data_collection(observation_data)
pStation.set_data(station_data)
# creer et ajouter infdata
# Creation and adding infdata
infdata_roadcast = metro_infdata.Metro_infdata(
'ROADCAST', metro_infdata.DATATYPE_METRO_DATA_COLLECTION)
infdata_roadcast.set_data_collection(roadcast_data)
self.add_infdata(infdata_roadcast)
def start( self ):
Metro_module.start(self)
pForecast = self.get_infdata_reference('FORECAST')
forecast_data = pForecast.get_data_collection()
pObservation = self.get_infdata_reference('OBSERVATION')
observation_data = pObservation.get_data_collection()
pStation = self.get_infdata_reference('STATION')
station_data = pStation.get_data()
if metro_config.get_value('T_BYPASS_CORE') == False:
self.__send_data_to_metro_core(forecast_data,
observation_data,
station_data )
roadcast_data = self.__create_roadcast_collection(forecast_data,
observation_data,
station_data)
else:
roadcast_data = None
metro_logger.print_message(
metro_logger.LOGGER_MSG_INFORMATIVE,
_("Bypassing METRo core, roadcast not created."))
pForecast.set_data_collection(forecast_data)
pObservation.set_data_collection(observation_data)
pStation.set_data(station_data)
# creer et ajouter infdata
# Creation and adding infdata
infdata_roadcast = metro_infdata.Metro_infdata(
'ROADCAST', metro_infdata.DATATYPE_METRO_DATA_COLLECTION)
infdata_roadcast.set_data_collection(roadcast_data)
self.add_infdata(infdata_roadcast)
def __check_if_cloud_octal(self, wf_controlled_data):
"""
Name: __check_if_cloud_octal
Parameters:[I] metro_data wf_controlled_data : controlled data.
Read-only data.
Returns: None
Functions Called: self.forecast_data.get_matrix_col
Description: Check if all the value of the variable CC is in [0,8]
Notes: Metro gives funny surface temperature if a strange value of CC
is entered. Raise an exception if this occurs.
Revision History:
Author Date Reason
Miguel Tremblay February 28th 2005
"""
npCloudsOctal = wf_controlled_data.get_matrix_col('CC')
if len(numpy.where(npCloudsOctal<0)[0]) != 0 or \
len(numpy.where(npCloudsOctal>8)[0]) != 0 :
import metro_config
sMessage = _("All the clouds value (<cc>) of atmospheric forecast must be") +\
_(" integers in interval 0-8. See file '%s'") %\
(metro_config.get_value("FILE_FORECAST_IN_FILENAME"))
raise metro_error.Metro_data_error(sMessage)
def __check_precipitation_well_define(self, wf_controlled_data):
"""
Name: __check_precipitation_well_define
Parameters:[I] metro_data wf_controlled_data : controlled data.
Read-only data.
Returns: None
Functions Called: self.forecast_data.get_matrix_col
Description: Check if the values of precipitations represent the total
amount of precipitation from the beginning of the period. Thus, all
the values must monotone in the RA and SN array.
Notes:
Revision History:
Author Date Reason
Miguel Tremblay February 28th 2005
"""
lPrecip = []
lPrecip.append(wf_controlled_data.get_matrix_col('RA'))
lPrecip.append(wf_controlled_data.get_matrix_col('SN'))
for npPrecip in lPrecip:
npDiff = npPrecip - metro_util.shift_right(npPrecip, 0)
if len(numpy.where(npDiff[:-1] < 0)[0]) != 0:
sMessage = _("All the precipitation value (<ra> and <sn>)") +\
_(" of atmospheric forecast represent the TOTAL") +\
_(" amount of precipitation since the beginning") +\
_(" of the period. See file '%s'") %\
(metro_config.get_value("FILE_FORECAST_IN_FILENAME"))
raise metro_error.Metro_data_error(sMessage)
def __set_cc(self, wf_controlled_data, wf_interpolated_data):
"""
In the case that SF and IR are given, put the values of CC to -1.
Parameters:
wf_controlled_data (metro_data) : controlled data. Read-only
"""
if metro_config.get_value('SF') and metro_config.get_value('IR'):
npTime = wf_controlled_data.get_matrix_col('Time')
npCloudOctal = wf_controlled_data.get_matrix_col('CC')
nLength = len(npCloudOctal)
npCloud = numpy.ones(nLength) * (-1)
npCloud2 = metro_util.interpolate(npTime, npCloud)
wf_controlled_data.set_matrix_col('CC', npCloud)
wf_interpolated_data.set_matrix_col('CC', npCloud2)
def __check_precipitation_well_define(self, wf_controlled_data):
"""
Name: __check_precipitation_well_define
Parameters:[I] metro_data wf_controlled_data : controlled data.
Read-only data.
Returns: None
Functions Called: self.forecast_data.get_matrix_col
Description: Check if the values of precipitations represent the total
amount of precipitation from the beginning of the period. Thus, all
the values must monotone in the RA and SN array.
Notes:
Revision History:
Author Date Reason
Miguel Tremblay February 28th 2005
"""
lPrecip = []
lPrecip.append(wf_controlled_data.get_matrix_col('RA'))
lPrecip.append(wf_controlled_data.get_matrix_col('SN'))
for npPrecip in lPrecip:
npDiff = npPrecip - metro_util.shift_right(npPrecip,0)
if len(numpy.where(npDiff[:-1] < 0)[0]) != 0:
sMessage = _("All the precipitation value (<ra> and <sn>)") +\
_(" of atmospheric forecast represent the TOTAL") +\
_(" amount of precipitation since the beginning") +\
_(" of the period. See file '%s'") %\
(metro_config.get_value("FILE_FORECAST_IN_FILENAME"))
raise metro_error.Metro_data_error(sMessage)
def __interpolate_FA(self, wf_originpl_data, wf_interpolated_data):
"""
Name: __interpolate_FA
Parameters:[I] metro_data wf_originpl_data : originpl data. Read-only
[I] metro_data wf_processed_data : container of the interpolated
data.
Returns: None
Functions Called: metro_util.interpolate,
metro_data.get_matrix_col
metro_data.append_matrix_col
Description: Does the interpolation of the anthropogenic flux
Revision History:
Author Date Reason
Rok Krsmanc October 22th 2010
"""
if metro_config.get_value('FA') == True:
npFA = wf_originpl_data.get_matrix_col('FA')
# If anthropogenic flux is not specified, FA is set to a constant value of 10 W/m^2
else:
lFA = [10]
npFA = numpy.array(lFA)
npFA = metro_util.interpolate(self.npTime, npFA)
wf_interpolated_data.append_matrix_col('FA', npFA)
def __check_if_cloud_octal(self, wf_controlled_data):
"""
Name: __check_if_cloud_octal
Parameters:[I] metro_data wf_controlled_data : controlled data.
Read-only data.
Returns: None
Functions Called: self.forecast_data.get_matrix_col
Description: Check if all the value of the variable CC is in [0,8]
Notes: Metro gives funny surface temperature if a strange value of CC
is entered. Raise an exception if this occurs.
Revision History:
Author Date Reason
Miguel Tremblay February 28th 2005
"""
npCloudsOctal = wf_controlled_data.get_matrix_col('CC')
if len(numpy.where(npCloudsOctal<0)[0]) != 0 or \
len(numpy.where(npCloudsOctal>8)[0]) != 0 :
import metro_config
sMessage = _("All the clouds value (<cc>) of atmospheric forecast must be") +\
_(" integers in interval 0-8. See file '%s'") %\
(metro_config.get_value("FILE_FORECAST_IN_FILENAME"))
raise metro_error.Metro_data_error(sMessage)
def start(self):
Metro_read.start(self)
if metro_config.key_exist('FILE_OBSERVATION_REF_FILENAME'):
sFilename = metro_config.get_value('FILE_OBSERVATION_REF_FILENAME')
else:
sFilename = ""
if sFilename != "":
try:
sFile_content = self._read_input_data(sFilename)
except IOError:
sError_message = _("No file was read. METRo may need this ") +\
_("file content later.")
metro_logger.print_message(metro_logger.LOGGER_MSG_CRITICAL,
sError_message)
else:
# creer et ajouter infdata
infdata_observation_ref = metro_infdata.Metro_infdata( \
'OBSERVATION_REF', \
metro_infdata.DATATYPE_METRO_DATA_COLLECTION)
infdata_observation_ref.set_input_information(sFile_content)
self.add_infdata(infdata_observation_ref)
else:
sError_message = _("If you want to read a second observation file,")+\
_("\nplease use the option: ") +\
_("'--input-observation-ref'.") +\
_("\nYou can safely remove this module from the ") +\
_("EXECUTION SEQUENCE\nif you don't need it.")
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
sError_message)
def __interpolate_FA(self, wf_originpl_data, wf_interpolated_data):
"""
Name: __interpolate_FA
Parameters:[I] metro_data wf_originpl_data : originpl data. Read-only
[I] metro_data wf_processed_data : container of the interpolated
data.
Returns: None
Functions Called: metro_util.interpolate,
metro_data.get_matrix_col
metro_data.append_matrix_col
Description: Does the interpolation of the anthropogenic flux
Revision History:
Author Date Reason
Rok Krsmanc October 22th 2010
"""
if metro_config.get_value('FA') == True:
npFA = wf_originpl_data.get_matrix_col('FA')
# If anthropogenic flux is not specified, FA is set to a constant value of 10 W/m^2
else:
lFA = [10]
npFA = numpy.array(lFA)
npFA = metro_util.interpolate(self.npTime, npFA)
wf_interpolated_data.append_matrix_col('FA', npFA)
def start(self):
Metro_read.start(self)
if metro_config.key_exist('FILE_OBSERVATION_REF_FILENAME'):
sFilename = metro_config.get_value('FILE_OBSERVATION_REF_FILENAME')
else:
sFilename = ""
if sFilename != "":
try:
sFile_content = self._read_input_data(sFilename)
except IOError:
sError_message = _("No file was read. METRo may need this ") +\
_("file content later.")
metro_logger.print_message(metro_logger.LOGGER_MSG_CRITICAL,
sError_message)
else:
# creer et ajouter infdata
infdata_observation_ref = metro_infdata.Metro_infdata( \
'OBSERVATION_REF', \
metro_infdata.DATATYPE_METRO_DATA_COLLECTION)
infdata_observation_ref.set_input_information(sFile_content)
self.add_infdata(infdata_observation_ref)
else:
sError_message = _("If you want to read a second observation file,")+\
_("\nplease use the option: ") +\
_("'--input-observation-ref'.") +\
_("\nYou can safely remove this module from the ") +\
_("EXECUTION SEQUENCE\nif you don't need it.")
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
sError_message)
def start(self):
Metro_read.start(self)
if metro_config.key_exist('FILE_OBSERVATION_FILENAME'):
sFilename = metro_config.get_value('FILE_OBSERVATION_FILENAME')
else:
sFilename = ""
if sFilename != "":
try:
sFile_content = self._read_input_data(sFilename)
except IOError:
sError_message = _("METRo need a valid observation file.")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
else:
# Create and add infdata
infdata_observation = metro_infdata.Metro_infdata(
'OBSERVATION',
metro_infdata.DATATYPE_METRO_DATA_COLLECTION)
infdata_observation.set_input_information(sFile_content)
self.add_infdata(infdata_observation)
else:
sError_message = _("METRo need an observation file, please use ") +\
_("the option: '--input-observation'")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
def start(self):
Metro_module.start(self)
pRoadcast = self.get_infdata_reference('ROADCAST')
roadcast_data = pRoadcast.get_data_collection()
#
# construct dictionnary of write handler
#
import toolbox.metro_metro2dom_handler
# Retrieve the informations about the data type
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
dWriteHandlers = {}
# construct dictionnary of write handlers (only done once so not expensive)
sMessage = _(
"-------------------------- Write handlers available --------------------------\n"
)
for dType in dData_type:
if dData_type[dType]['WRITE'] != "":
sCode = "handler = " + dData_type[dType]['WRITE']
exec sCode
dWriteHandlers[dType] = handler
sMessage += _("TYPE: %s , HANDLER: %s\n") % (
dType.ljust(15), dData_type[dType]['WRITE'])
sMessage += "-----------------------------------------------------------------------------"
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG, sMessage)
# Create roadcast
if roadcast_data != None:
domRoadcast = \
self.__create_roadcast(roadcast_data.get_subsampled_data(),dWriteHandlers)
else:
metro_logger.print_message(
metro_logger.LOGGER_MSG_WARNING,
_("No roadcast, can't create DOM roadcast"))
domRoadcast = None
pRoadcast.set_output_information(domRoadcast)
def __check_deep_soil_value(self):
"""
Description: Check if the value given to --fix-deep-soil-temperature
is valid.
"""
# If the option is not used, do not perform the check
if not metro_config.get_value('DEEP_SOIL_TEMP'):
return
# Check if the option is given while on a bridge
pStation = self.get_infdata_reference('STATION')
station_data = pStation.get_data()
if station_data.get_station_type():
sMessage = _("Option '--fix-deep-soil-temperature' is used while ") +\
_("the station is of type BRIDGE. Deep soil ") +\
_("Temperature will not be used.")
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,\
sMessage)
else: # In case of a road verify if the value is a double
sTemperature = metro_config.get_value('DEEP_SOIL_TEMP_VALUE')
try:
dTemperature = float(sTemperature)
if dTemperature > metro_constant.nRoadTemperatureHigh or \
dTemperature < metro_constant.nRoadTemperatureMin:
sMessage = _("Deep soil temperature following the option ")+\
_("'-fix-deep-soil-temperature' must be between ") +\
_("boundaries [") +\
str(metro_constant.nRoadTemperatureMin)+ "," +\
str(metro_constant.nRoadTemperatureHigh)+ "]. '"+\
sTemperature + "' is not in those boundaries."
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
# If there is no error, the value is a number, we can continue
sMessage = _("Using deep soil temperature: ") + sTemperature +\
_(" degree Celsius")
metro_logger.print_message(metro_logger.LOGGER_MSG_INFORMATIVE,\
sMessage)
except ValueError:
sMessage = _("Option '-fix-deep-soil-temperature' must be ") +\
_("followed by a numeric value. The given value '") +\
sTemperature + _("' is not a number.")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
def start( self ):
Metro_module.start(self)
pRoadcast = self.get_infdata_reference('ROADCAST')
roadcast_data = pRoadcast.get_data_collection()
#
# construct dictionnary of write handler
#
import toolbox.metro_metro2dom_handler
# Retrieve the informations about the data type
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
dWriteHandlers = {}
# construct dictionnary of write handlers (only done once so not expensive)
sMessage = _("-------------------------- Write handlers available --------------------------\n")
for dType in dData_type:
if dData_type[dType]['WRITE'] != "":
sCode = "handler = " + dData_type[dType]['WRITE']
exec sCode
dWriteHandlers[dType] = handler
sMessage += _("TYPE: %s , HANDLER: %s\n") % (dType.ljust(15),dData_type[dType]['WRITE'])
sMessage += "-----------------------------------------------------------------------------"
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG,
sMessage)
# Create roadcast
if roadcast_data != None:
domRoadcast = \
self.__create_roadcast(roadcast_data.get_subsampled_data(),dWriteHandlers)
else:
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
_("No roadcast, can't create DOM roadcast"))
domRoadcast = None
pRoadcast.set_output_information(domRoadcast)
def __check_deep_soil_value(self):
"""
Description: Check if the value given to --fix-deep-soil-temperature
is valid.
"""
# If the option is not used, do not perform the check
if not metro_config.get_value('DEEP_SOIL_TEMP'):
return
# Check if the option is given while on a bridge
pStation = self.get_infdata_reference('STATION')
station_data = pStation.get_data()
if station_data.get_station_type():
sMessage = _("Option '--fix-deep-soil-temperature' is used while ") +\
_("the station is of type BRIDGE. Deep soil ") +\
_("Temperature will not be used.")
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,\
sMessage)
else: # In case of a road verify if the value is a double
sTemperature = metro_config.get_value('DEEP_SOIL_TEMP_VALUE')
try:
dTemperature = float(sTemperature)
if dTemperature > metro_constant.nRoadTemperatureHigh or \
dTemperature < metro_constant.nRoadTemperatureMin:
sMessage = _("Deep soil temperature following the option ")+\
_("'-fix-deep-soil-temperature' must be between ") +\
_("boundaries [") +\
str(metro_constant.nRoadTemperatureMin)+ "," +\
str(metro_constant.nRoadTemperatureHigh)+ "]. '"+\
sTemperature + "' is not in those boundaries."
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
# If there is no error, the value is a number, we can continue
sMessage = _("Using deep soil temperature: ") + sTemperature +\
_(" degree Celsius")
metro_logger.print_message(metro_logger.LOGGER_MSG_INFORMATIVE,\
sMessage)
except ValueError:
sMessage = _("Option '-fix-deep-soil-temperature' must be ") +\
_("followed by a numeric value. The given value '") +\
sTemperature + _("' is not a number.")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
def __set_time(self, ro_controlled_data, ro_interpolated_data,
observation_data):
"""
Name: __set_time
Parameters: metro_data controlled_data : controlled forecast data
Returns: None
Functions Called: numpy.arange, astype
numpy.zeros
metro_data.set_matrix
metro_data.get_matrix_col
metro_data.append_matrix_col
observation_data.set_attribute
metro_config.get_value('FILE_OBSERVATION_FILENAME')
Description: Set the time array in the interpolated matrix.
Notes:
Revision History:
Author Date Reason
Miguel Tremblay August 5th 2004
"""
# Set the time in the interpolated matrix.
npTime = ro_controlled_data.get_matrix_col('Time')
self.npTimeInterpolated = numpy.arange(npTime[0], \
npTime[len(npTime)-1],
metro_constant.fTimeStep)
# 1.1574e-5 is the conversion from seconds to day.
# 1/(24*3600) = 1.1574e-5
self.npTimeInterpolated = self.npTimeInterpolated/3600 -\
24*((self.npTimeInterpolated*1.1574e-5)\
.astype(numpy.int32))
# Save the time array
if len(self.npTimeInterpolated) > 1:
ro_interpolated_data.append_matrix_col('Time', \
self.npTimeInterpolated)
# Only one observation, abort interpolation
elif len(self.npTimeInterpolated) == 1:
observation_data.set_attribute('NO_OBS',\
[False, False, False, True])
raise metro_error.Metro_input_error(OneObservationException)
else:
observation_data.set_attribute('NO_OBS',\
[True, True, True, True])
sMessage = _("No valid observation in: ") +\
metro_config.get_value('FILE_OBSERVATION_FILENAME')
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sMessage)
raise metro_error.Metro_input_error(NoObservationException)
def validate_datatype(dConf):
# extract data type
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dAll_data_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
# validate Metro standard data type
sConfig_item = 'XML_DATATYPE_STANDARD'
iFrom = dConf[sConfig_item]['FROM']
validate_datatype_category(sConfig_item, iFrom, dStandard_data_type,
dAll_data_type)
# validate User data type
sConfig_item = 'XML_DATATYPE_EXTENDED'
iFrom = dConf[sConfig_item]['FROM']
validate_datatype_category(sConfig_item, iFrom, dExtended_data_type,
dAll_data_type)
def __set_time(self, ro_controlled_data, ro_interpolated_data,
observation_data):
"""
Name: __set_time
Parameters: metro_data controlled_data : controlled forecast data
Returns: None
Functions Called: numpy.arange, astype
numpy.zeros
metro_data.set_matrix
metro_data.get_matrix_col
metro_data.append_matrix_col
observation_data.set_attribute
metro_config.get_value('FILE_OBSERVATION_FILENAME')
Description: Set the time array in the interpolated matrix.
Notes:
Revision History:
Author Date Reason
Miguel Tremblay August 5th 2004
"""
# Set the time in the interpolated matrix.
npTime = ro_controlled_data.get_matrix_col('Time')
self.npTimeInterpolated = numpy.arange(npTime[0], \
npTime[len(npTime)-1],
metro_constant.fTimeStep)
# 1.1574e-5 is the conversion from seconds to day.
# 1/(24*3600) = 1.1574e-5
self.npTimeInterpolated = self.npTimeInterpolated/3600 -\
24*((self.npTimeInterpolated*1.1574e-5)\
.astype(numpy.int32))
# Save the time array
if len(self.npTimeInterpolated) > 1:
ro_interpolated_data.append_matrix_col('Time', \
self.npTimeInterpolated)
# Only one observation, abort interpolation
elif len(self.npTimeInterpolated) == 1:
observation_data.set_attribute('NO_OBS',\
[False, False, False, True])
raise metro_error.Metro_input_error(OneObservationException)
else:
observation_data.set_attribute('NO_OBS',\
[True, True, True, True])
sMessage = _("No valid observation in: ") +\
metro_config.get_value('FILE_OBSERVATION_FILENAME')
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP, sMessage)
raise metro_error.Metro_input_error(NoObservationException)
def start(self):
Metro_write.start(self)
pForecast = self.get_infdata_reference('FORECAST')
self.domForecast = pForecast.get_output_information()
if self.domForecast != None:
sFilename = metro_config.get_value('FILE_FORECAST_OUT_FILENAME')
self._write_dom(sFilename,self.domForecast)
else:
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
_("no DOM forecast, nothing to write"))
pForecast.set_output_information(None)
def start(self):
Metro_write.start(self)
pForecast = self.get_infdata_reference('FORECAST')
self.domForecast = pForecast.get_output_information()
if self.domForecast != None:
sFilename = metro_config.get_value('FILE_FORECAST_OUT_FILENAME')
self._write_dom(sFilename, self.domForecast)
else:
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
_("no DOM forecast, nothing to write"))
pForecast.set_output_information(None)
def roadlayer_type_to_roadlayer_code(sLayerType):
dValidLayerType = metro_config.get_value(\
'XML_STATION_ROADLAYER_VALID_TYPE')
sLayerType = sLayerType.upper()
if sLayerType in dValidLayerType:
iLayer_code = dValidLayerType[sLayerType]
else:
# raise an error
sMessage = _("'%s' is not a valid road layer type. ") % (sLayerType) +\
_("Valid type are %s " ) % (dValidLayerType.keys()) +\
_("Check the station configuration file")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP, sMessage)
return iLayer_code
def create_node_tree_from_dict( domDoc, nodeParent, lDefs, dWriteHandlers, dData ):
# Retrieve the informations on the data types
dStandard_data_type = metro_config.get_value('XML_DATATYPE_STANDARD')
dExtended_data_type = metro_config.get_value('XML_DATATYPE_EXTENDED')
dData_type = metro_util.join_dictionaries(dStandard_data_type,
dExtended_data_type)
for dDef in lDefs:
# Retrieve the name and the item type
sTag = dDef['NAME']
sXml_tag = dDef['XML_TAG']
sData_type_name = dDef['DATA_TYPE']
if dData_type[sData_type_name].has_key('CHILD'):
# create the node containing a list of "sub-node"
lChildList = dData_type[sData_type_name]['CHILD']
nodeData = dWriteHandlers[sData_type_name](sXml_tag,lChildList,dData[sTag],dWriteHandlers)
else:
# create the node
nodeData = dWriteHandlers[sData_type_name](sXml_tag,dData[sTag])
append_child(nodeParent, nodeData)
def roadlayer_type_to_roadlayer_code(sLayerType):
dValidLayerType = metro_config.get_value(\
'XML_STATION_ROADLAYER_VALID_TYPE')
sLayerType = sLayerType.upper()
if sLayerType in dValidLayerType:
iLayer_code = dValidLayerType[sLayerType]
else:
# raise an error
sMessage = _("'%s' is not a valid road layer type. ") % (sLayerType) +\
_("Valid type are %s " ) % (dValidLayerType.keys()) +\
_("Check the station configuration file")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP, sMessage)
return iLayer_code
def start(self):
Metro_postprocess.start(self)
pRoadcast = self.get_infdata_reference('ROADCAST')
roadcast_data = pRoadcast.get_data_collection()
iPrecision = \
metro_config.get_value('DEFAULT_ROADCAST_PREDICTION_PRECISION')
if roadcast_data != None:
self.__round_roadcast_header(roadcast_data.get_subsampled_data())
self.__round_roadcast_data(roadcast_data.get_subsampled_data())
else:
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
_("No roadcast!"))
pRoadcast.set_data_collection(roadcast_data)
def start(self):
Metro_postprocess.start(self)
pRoadcast = self.get_infdata_reference('ROADCAST')
roadcast_data = pRoadcast.get_data_collection()
iPrecision = \
metro_config.get_value('DEFAULT_ROADCAST_PREDICTION_PRECISION')
if roadcast_data != None:
self.__round_roadcast_header(roadcast_data.get_subsampled_data())
self.__round_roadcast_data(roadcast_data.get_subsampled_data())
else:
metro_logger.print_message(metro_logger.LOGGER_MSG_WARNING,
_("No roadcast!"))
pRoadcast.set_data_collection(roadcast_data)
def get_sst_depth(self):
"""
Get the sensor SST depth value
Return 0.4 if value in station config file is not between 0.2 and 0.6 and if no flag '--use-sst-sensor-depth' is used. Else returns value provided for sensor SST depth in station config file.
"""
if metro_config.get_value('SST_DEPTH') == False:
return 0.4
else:
dStation_header = self.get_header()
sStation_sst_depth = dStation_header['SST_DEPTH']
if sStation_sst_depth == "None" or sStation_sst_depth > 0.6 or sStation_sst_depth < 0.2:
sMessage = _("Sensor SST depth value in station config file is not between 0.2 and 0.6. Value 0.4 for sensor SST depth will be used.")
metro_logger.print_message(metro_logger.LOGGER_MSG_CRITICAL,\
sMessage)
return 0.4
else:
return sStation_sst_depth
def get_station_type(self):
"""Get the station type
Return True if the station is on a bridge, False if on the road.
"""
dStation_header = self.get_header()
sStation_type = dStation_header['STATION_TYPE']
if sStation_type == "road" or sStation_type == "route":
bFlat = False
elif sStation_type == "bridge" or sStation_type == "pont":
bFlat = True
else:
sMessage = _("Wrong argument in the station config file %s.") \
% (metro_config.get_value('FILE_STATION_FILENAME')) +\
_("Station type must be \"road\" or \"bridge\". ") + \
_( "Using \"road\" as default.")
metro_logger.print_message(metro_logger.LOGGER_MSG_CRITICAL,\
sMessage)
bFlat = False
return bFlat
def get_station_type(self):
"""Get the station type
Return True if the station is on a bridge, False if on the road.
"""
dStation_header = self.get_header()
sStation_type = dStation_header['STATION_TYPE']
if sStation_type == "road" or sStation_type == "route":
bFlat = False
elif sStation_type == "bridge" or sStation_type == "pont":
bFlat = True
else:
sMessage = _("Wrong argument in the station config file %s.") \
% (metro_config.get_value('FILE_STATION_FILENAME')) +\
_("Station type must be \"road\" or \"bridge\". ") + \
_( "Using \"road\" as default.")
metro_logger.print_message(metro_logger.LOGGER_MSG_CRITICAL,\
sMessage)
bFlat = False
return bFlat
def __create_roadcast( self, data, dWriteHandlers ):
#
# DOM and root element creation
#
sRoot_xpath = metro_config.get_value('XML_ROADCAST_XPATH_ROOT')
domDoc = metro_xml.create_dom(sRoot_xpath)
nodeRoot = metro_xml.get_dom_root(domDoc)
#
# Roadcast header creation
#
# Concatenation of all header keys
lHeader_keys = \
metro_config.get_value('XML_ROADCAST_HEADER_STANDARD_ITEMS') + \
metro_config.get_value('XML_ROADCAST_HEADER_EXTENDED_ITEMS')
# xpath creation
sHeader_xpath = metro_config.get_value('XML_ROADCAST_XPATH_HEADER')
self.__create_header(domDoc, nodeRoot, sHeader_xpath,
lHeader_keys, dWriteHandlers, data)
#
# reation of the roadcast matrix
#
# Concatentation of all prediction types
lPrediction_keys = \
metro_config.get_value('XML_ROADCAST_PREDICTION_STANDARD_ITEMS') + \
metro_config.get_value('XML_ROADCAST_PREDICTION_EXTENDED_ITEMS')
# xpath creation
sPrediction_xpath = \
metro_config.get_value('XML_ROADCAST_XPATH_PREDICTION')
self.__create_matrix(domDoc, nodeRoot, sPrediction_xpath,
lPrediction_keys, dWriteHandlers, data)
return domDoc
def __create_roadcast(self, data, dWriteHandlers):
#
# DOM and root element creation
#
sRoot_xpath = metro_config.get_value('XML_ROADCAST_XPATH_ROOT')
domDoc = metro_xml.create_dom(sRoot_xpath)
nodeRoot = metro_xml.get_dom_root(domDoc)
#
# Roadcast header creation
#
# Concatenation of all header keys
lHeader_keys = \
metro_config.get_value('XML_ROADCAST_HEADER_STANDARD_ITEMS') + \
metro_config.get_value('XML_ROADCAST_HEADER_EXTENDED_ITEMS')
# xpath creation
sHeader_xpath = metro_config.get_value('XML_ROADCAST_XPATH_HEADER')
self.__create_header(domDoc, nodeRoot, sHeader_xpath, lHeader_keys,
dWriteHandlers, data)
#
# reation of the roadcast matrix
#
# Concatentation of all prediction types
lPrediction_keys = \
metro_config.get_value('XML_ROADCAST_PREDICTION_STANDARD_ITEMS') + \
metro_config.get_value('XML_ROADCAST_PREDICTION_EXTENDED_ITEMS')
# xpath creation
sPrediction_xpath = \
metro_config.get_value('XML_ROADCAST_XPATH_PREDICTION')
self.__create_matrix(domDoc, nodeRoot, sPrediction_xpath,
lPrediction_keys, dWriteHandlers, data)
return domDoc
def start(self):
Metro_read.start(self)
if metro_config.key_exist('FILE_FORECAST_IN_FILENAME'):
sFilename = metro_config.get_value('FILE_FORECAST_IN_FILENAME')
try:
sFile_content = self._read_input_data(sFilename)
except IOError:
sError_message = _("METRo need a valid forecast file.")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
else:
# Create and append infdata
infdata_forecast = metro_infdata.Metro_infdata(
'FORECAST', metro_infdata.DATATYPE_METRO_DATA_COLLECTION)
infdata_forecast.set_input_information(sFile_content)
self.add_infdata(infdata_forecast)
else:
sError_message = _("METRo need a forecast file, please use the ") +\
_("option: '--input-forecast'")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
def start(self):
Metro_read.start(self)
if metro_config.key_exist('FILE_FORECAST_IN_FILENAME'):
sFilename = metro_config.get_value('FILE_FORECAST_IN_FILENAME')
try:
sFile_content = self._read_input_data(sFilename)
except IOError:
sError_message = _("METRo need a valid forecast file.")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
else:
# Create and append infdata
infdata_forecast = metro_infdata.Metro_infdata(
'FORECAST', metro_infdata.DATATYPE_METRO_DATA_COLLECTION)
infdata_forecast.set_input_information(sFile_content)
self.add_infdata(infdata_forecast)
else:
sError_message = _("METRo need a forecast file, please use the ") +\
_("option: '--input-forecast'")
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,
sError_message)
def __set_ir(self, wf_controlled_data, wf_interpolated_data):
"""
Set the theoretical infrared flux.
Parameters:
wf_controlled_data (metro_data) : controlled data. Read-only
"""
npTime = wf_controlled_data.get_matrix_col('Time')
# Only interpolate if IR is given
if metro_config.get_value('IR'):
npIR = wf_controlled_data.get_matrix_col('IR')
npIR2 = metro_util.interpolate(npTime, npIR)
wf_interpolated_data.append_matrix_col('IR', npIR2)
return
npCloudOctal = wf_controlled_data.get_matrix_col('CC')
(npCoeff1, npCoeff2) = metro_physics.get_cloud_coefficient(npCloudOctal)
npAT = wf_controlled_data.get_matrix_col('AT')
npIR = npCoeff1*npAT+npCoeff2
npIR2 = metro_util.interpolate(npTime, npIR)
wf_controlled_data.append_matrix_col('IR', npIR)
wf_interpolated_data.append_matrix_col('IR', npIR2)
def get_sst_depth(self):
"""
Get the sensor SST depth value
Return 0.4 if no flag '--use-sst-sensor-depth' is used.
Else returns value provided for sensor SST depth in station config file,
provided that it is included in METRo grid, ie. [0.01,1.4] m.
See METRo documentation page for more details:
https://framagit.org/metroprojects/metro/wikis/Vertical_levels_(METRo)
"""
if metro_config.get_value('SST_DEPTH') == False:
return 0.4
else:
dStation_header = self.get_header()
fStation_sst_depth = dStation_header['SST_DEPTH']
if fStation_sst_depth == "None" \
or fStation_sst_depth > 1.4 \
or fStation_sst_depth < 0.01:
sMessage = _("Sensor SST depth value in station config file is not between 0.01 m and 1.4 m. Given value: '%s' m.") \
% fStation_sst_depth
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage)
else:
return fStation_sst_depth
def __check_time_order(self, ro_controlled_data, wf_controlled_data):
"""
Name: __check_time_order
Parameters: metro_data controlled_data : controlled observation data
Returns: None
Functions Called: metro_data.get_matrix_col
metro_util.get_difference_array
numpy.where, nonzero, arange
metro_date.get_day, get_hour, get_minute
metro_data.del_matrix_row
metro_logger.print_message
Description: Check if the time of the observation are in order.
Cut the information that are spaced by more than 240 minutes.
Notes:
Revision History:
Author Date Reason
Miguel Tremblay August 4th 2004
"""
npTime = ro_controlled_data.get_matrix_col('Time')
npCheck = metro_util.get_difference_array(npTime)
# If a gap of more than nGapMinuteObservation
# minutes is identify, cut the value before.
npCheck = metro_util.get_difference_array(npTime)
npBad = numpy.where( npCheck > metro_constant.\
nGapMinuteObservation*60, 1, 0)
npBadIndice = (numpy.nonzero(npBad))[0]
if len(npBadIndice) > 0:
sMessage = _("More than %d minutes between 2 measures")\
% (metro_constant.nGapMinuteObservation)
metro_logger.print_message(metro_logger.LOGGER_MSG_INFORMATIVE,\
sMessage)
npOT = ro_controlled_data.get_matrix_col('OBSERVATION_TIME')
for i in range(0,len(npBadIndice)):
nIndice = npBadIndice[i]
sMessage = _("Indice: %d") % (nIndice)
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG,\
sMessage)
sMessage = _("Cutoff time: day:%d hour:%d minute:%d") %\
(metro_date.get_day(npOT[nIndice]),\
metro_date.get_hour(npOT[nIndice]),\
metro_date.get_minute(npOT[nIndice]))
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG,\
sMessage)
toto = numpy.arange(0,npBadIndice[len(npBadIndice)-1]+1)
ro_controlled_data.del_matrix_row(toto)
npTime = ro_controlled_data.get_matrix_col('Time')
npBad = numpy.where( npCheck < 0, 1, 0)
npBadIndice = (numpy.nonzero(npBad))[0]
# Accept 1 value under zero because the last value of
# npBadIndice = npCheck[len(npCheck)-1] - npCheck[0]
if len(npBadIndice) > 1:
sMessage = _("Time of observation are not in order. ") + \
_("Check the %d th value") %(npBadIndice[1])
metro_logger.print_message(metro_logger.LOGGER_MSG_STOP,\
sMessage )
# Remove the values that are equal.
npBad = numpy.where( npCheck == 0, 1, 0)
npBadIndice = (numpy.nonzero(npBad))[0]
ro_controlled_data.del_matrix_row(npBadIndice)
########################################################
npFT = wf_controlled_data.get_matrix_col('FORECAST_TIME')
npOT = ro_controlled_data.get_matrix_col('Time')
nHourStart = metro_date.get_hour(npFT[0])
npDiff = - npOT + nHourStart*3600
npBad = numpy.where(npDiff > metro_constant.\
nHourForExpirationOfObservation*3600, 1, 0)
if len(npBad) > 0:
npBadIndices = (numpy.nonzero(npBad))[0]
if len(npBadIndices) > 0:
npBadIndices = (numpy.nonzero(npBad))[0]
sMessage = _("Observation is more than %d hours") \
% ( metro_constant.nHourForExpirationOfObservation)\
+ _("before the first roadcast")
metro_logger.print_message(metro_logger.LOGGER_MSG_INFORMATIVE,
sMessage)
for i in range(0,len(npBadIndices)):
nIndice = npBadIndices[i]
sMessage = _("Indice: %d") % (nIndice)
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG,
sMessage)
ro_controlled_data.del_matrix_row(npBadIndices)
# Get start time
sStart_time = metro_config.get_value('INIT_ROADCAST_START_DATE')
# If start time is not specified, default will be used
if sStart_time == "":
return
# Check if the observation are not before the start of the roadcast
# if specified.
fStart_time = metro_date.parse_date_string(sStart_time)
npOT = ro_controlled_data.get_matrix_col('Time')\
+nHourStart*3600
npDiff = - npOT + int(metro_date.get_hour(fStart_time))*3600
npBad = numpy.where(npDiff > metro_constant\
.nHourForExpirationOfObservation*3600, 1, 0)
if len(npBad) > 0:
npBadIndices = (numpy.nonzero(npBad))[0]
if len(npBadIndices) > 0:
sMessage = _("Observation after the first roadcast time of METRo")
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG,\
sMessage)
sMessage = _("Threshold: %d") \
% (int(metro_date.get_hour(fStart_time))*3600 \
+ int(metro_date.get_month(fStart_time))*60)
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG,\
sMessage)
for i in range(0,len(npBadIndices)):
nIndice = npBadIndices[i]
sMessage = _("Time difference: %f") \
% (npDiff[nIndice])
metro_logger.print_message(metro_logger.LOGGER_MSG_DEBUG,\
sMessage)
ro_controlled_data.del_matrix_row(npBadIndices)
