climate-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From boust...@apache.org
Subject [2/3] climate git commit: adding new cli code
Date Wed, 03 Jun 2015 17:12:57 GMT
adding new cli code


Project: http://git-wip-us.apache.org/repos/asf/climate/repo
Commit: http://git-wip-us.apache.org/repos/asf/climate/commit/56929b07
Tree: http://git-wip-us.apache.org/repos/asf/climate/tree/56929b07
Diff: http://git-wip-us.apache.org/repos/asf/climate/diff/56929b07

Branch: refs/heads/master
Commit: 56929b07f8595c6d0a5346e46bc11a8785de3a14
Parents: f0e8948
Author: Maziyar Boustani <boustani@jpl.nasa.gov>
Authored: Thu May 28 12:09:12 2015 -0700
Committer: Maziyar Boustani <boustani@jpl.nasa.gov>
Committed: Thu May 28 12:09:12 2015 -0700

----------------------------------------------------------------------
 ocw-cli/cli_app.py | 1419 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1419 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/climate/blob/56929b07/ocw-cli/cli_app.py
----------------------------------------------------------------------
diff --git a/ocw-cli/cli_app.py b/ocw-cli/cli_app.py
new file mode 100644
index 0000000..40e797b
--- /dev/null
+++ b/ocw-cli/cli_app.py
@@ -0,0 +1,1419 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import curses
+import sys
+import os
+import numpy as np
+import getpass
+import urllib2
+import json
+
+from netCDF4 import Dataset
+from datetime import datetime, timedelta
+
+import ocw.metrics as metrics
+import ocw.plotter as plotter
+import ocw.dataset_processor as dsp
+import ocw.evaluation as evaluation
+import ocw.data_source.rcmed as rcmed
+from ocw.dataset import Bounds
+from ocw.data_source.local import load_file
+import ocw.utils as utils
+import ocw.data_source.esgf as esgf
+
+import ssl
+if hasattr(ssl, '_create_unverified_context'):
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+def ready_screen(page, note=""):
+    ''' Generates page borders, header, footer and notification center.
+
+    :param page: Name of current page
+    :type page: string
+    :param note: Notification that system returns and will be shown
+         at the bottom of page
+    :type note: string
+
+    :returns: y and x as location of text on screen
+    :rtype: integer
+    '''
+
+    screen.clear()
+    y, x = screen.getmaxyx()
+    screen.border(0)
+    screen.addstr(0, x/2-len(TITLE)/2, TITLE)
+    screen.addstr(y-1, x/2-len(ORGANIZATION)/2, ORGANIZATION)
+    screen.addstr(y-3, 1, "Notification:")
+    for each in range(1, x-1):
+         screen.addstr(y-4, each, "-")
+    if page == "main_menu":
+         screen.addstr(y-3, x-21, "(NC) = Not complete")
+         screen.addstr(y-2, x-21, "(C)  = Complete")
+    if page == "settings_screen":
+         for i in range(y-5):
+              screen.addstr(i+1, x/2-2, ".")
+    screen.addstr(y-2, 1, note)
+
+    return y, x
+
+
+def get_esgf_netCDF_file_name(esgf_dataset_id, esgf_variable):
+    dataset_info = esgf._get_file_download_data(esgf_dataset_id, esgf_variable)
+    netCDF_name = dataset_info[0][0].split("/")[-1]
+
+    return netCDF_name
+
+
+##############################################################
+#         Manage Model Screen
+##############################################################
+
+def load_local_model_screen(header):
+    '''Generates screen to be able to load local model file.
+    Path to model file (netCDF) and variable name is required.
+
+    :param header: Header of page
+    :type header: string
+
+    :returns: Notification
+    :rtype: string
+    '''
+
+    ready_screen("load_local_model_screen")
+    screen.addstr(1, 1, header + " > Load Local Model File ")
+    screen.addstr(4, 2, "Enter model path: ")
+    model_path = screen.getstr()
+    try:
+         netCDF_file = Dataset(model_path, 'r')
+         all_netcdf_variables = [variable.encode() for variable in netCDF_file.variables.keys()]
+         try:
+              screen.addstr(6, 2, "Enter model variable name {0}: ".format(all_netcdf_variables))
+              variable_name = screen.getstr()
+              screen.addstr(7, 4, "{0}".format(netCDF_file.variables[variable_name]))
+              screen.addstr(20, 2, "Confirm:")
+              screen.addstr(21, 4, "0- No")
+              screen.addstr(22, 4, "1- Yes")
+              screen.addstr(23, 3, "Would you take this variable:")
+              answer = screen.getstr()
+              if answer == "0":
+                   note = "WARNING: Model file cannot be added."
+              elif answer == "1":
+                   model_dataset = load_file(model_path, variable_name)
+                   model_datasets.append(model_dataset)
+                   models_info.append({'directory': model_path, 'variable_name': variable_name})
+                   note = "Model file successfully added."
+              else:
+                   note = "WARNING: Model file cannot be added."
+         except:
+              note = "WARNING: Model file cannot be added. The variable [{0}] is not accepted. Please try again.".format(variable_name)
+         netCDF_file.close()
+    except:
+         note = "WARNING: Model file cannot be read. Please check the file directory or format. Only netCDF format is accepted."
+
+    return note
+
+
+def load_esgf_model_screen(header):
+    '''Generates screen to be able to load ESGF model file.
+
+    :param header: Header of page
+    :type header: string
+
+    :returns: Notification
+    :rtype: string
+    '''
+
+    ready_screen("load_esgf_model_screen")
+    screen.addstr(1, 1, header + " > Download ESGF Dataset ")
+    screen.addstr(6, 1, "Enter Dataset ID:")
+    esgf_dataset_id = screen.getstr()
+    screen.addstr(7, 1, "Enter Variable:")
+    esgf_variable = screen.getstr()
+    screen.addstr(8, 1, "Enter Username:")
+    esgf_username = screen.getstr()
+    screen.addstr(9, 1, "Enter Password:")
+    esgf_password = screen.getstr()
+    try:
+        solr_url = "http://esg-datanode.jpl.nasa.gov/esg-search/search?id={0}&variable={1}&format=application%2Fsolr%2Bjson".format(esgf_dataset_id, esgf_variable)
+        metadata_json = json.load(urllib2.urlopen(solr_url))
+        if metadata_json['response']['docs'][0]["product"][0] != "observations":
+            screen.addstr(11, 4, "Title: {0}".format(metadata_json['response']['docs'][0]['title']))
+            screen.addstr(12, 4, "Start Date: {0}".format(metadata_json['response']['docs'][0]['datetime_start']))
+            screen.addstr(13, 4, "End Date: {0}".format(metadata_json['response']['docs'][0]['datetime_stop']))
+            screen.addstr(15, 2, "Confirm:")
+            screen.addstr(16, 4, "0- No")
+            screen.addstr(17, 4, "1- Yes")
+            screen.addstr(18, 3, "Would you take this dataset:")
+            answer = screen.getstr()
+            if answer == "0":
+                note = "WARNING: ESGF model file cannot be added."
+            elif answer == "1":
+                try:
+                    screen.addstr(20, 4, "Downloading dataset.....")
+                    screen.refresh()
+                    datasets = esgf.load_dataset(esgf_dataset_id,
+                                                esgf_variable,
+                                                esgf_username,
+                                                esgf_password)
+                    netCDF_name = get_esgf_netCDF_file_name(esgf_dataset_id, esgf_variable)
+                    netCDF_path = "/tmp/{0}".format(netCDF_name)
+                    model_dataset = load_file(netCDF_path, esgf_variable)
+                    model_datasets.append(model_dataset)
+                    models_info.append({'directory': netCDF_path, 'variable_name': esgf_variable})
+                    note = "Dataset successfully downloaded."
+                except:
+                    note = "WARNING: Dataset has not been downloaded. Check your ESGF permission."
+        else:
+            note = "The selected dataset is Observation, please enter model dataset."
+    except:
+        note = "WARNING: Something went wrong in downloading model dataset from ESGF."
+
+    return  note
+
+
+def unload_model_screen(header):
+    '''Generates screen to be able to unload model file.
+    It lists all loaded model with index for each.
+    Selection of model with index will remove model from list of models.
+
+    :param header: Header of page
+    :type header: string
+
+    :returns: Notification
+    :rtype: string
+    '''
+
+    ready_screen("unload_model_screen")
+    screen.addstr(1, 1, header + " > Unload Model File")
+    screen.addstr(6, 1, "List of Model:")
+    for i, model in enumerate(models_info):
+         screen.addstr(8 + i, 10, "Model Number:[{0}] - Model path:[{1}] - Variables:[{2}]".format(str(i), model['directory'], model['variable_name']))
+    screen.addstr(3, 2, "Select the model number to remove (press enter to go back): ")
+    try:
+         model_remove_index = screen.getstr()
+         models_info.pop(int(model_remove_index))
+         model_datasets.pop(int(model_remove_index))
+         note = "Model file unloaded successfully"
+    except:
+         note = "WARNING: Model file not unloaded successfully."
+
+    return note
+
+
+def list_model_screen(header):
+    '''Generates screen to list all model files.
+
+    :param header: Header of page
+    :type header: string
+    '''
+
+    ready_screen("list_model_screen")
+    screen.addstr(1, 1, header + " > List Model File ")
+    screen.addstr(6, 6, "List of model(s): ")
+    for i, model in enumerate(models_info):
+         screen.addstr(8 + i, 10, "Model Number:[{0}] - Model path:[{1}] - Variables:[{2}]".format(str(i), model['directory'], model['variable_name']))
+    screen.addstr(4, 4, "Return to Manage Model (press Enter) :")
+    screen.getstr()
+
+
+def manage_model_screen(header, note=""):
+    '''Generates Manage Model screen.
+
+    :param header: Header of page
+    :type header: string
+    :param note: Notification, defult to empty string.
+    :type note: string
+    '''
+
+    option = ''
+    while option != '0':
+         ready_screen("manage_model_screen", note)
+         screen.addstr(1, 1, header)
+         screen.addstr(4, 4, "1 - Load Local Model File")
+         screen.addstr(6, 4, "2 - Load ESGF Model File")
+         screen.addstr(8, 4, "3 - Unload Model File")
+         screen.addstr(10, 4, "4 - List Model File")
+         screen.addstr(12, 4, "0 - Return to Main Menu")
+         screen.addstr(14, 2, "Select an option: ")
+         screen.refresh()
+         option = screen.getstr()
+
+         if option == '1':
+              note = load_local_model_screen(header)
+         if option == '2':
+              note = load_esgf_model_screen(header)
+         if option == '3':
+              note = unload_model_screen(header)
+         if option == '4':
+              note = list_model_screen(header)
+              note = " "
+
+
+##############################################################
+#     Manage Observation Screen
+##############################################################
+
+def select_obs_screen(header):   #TODO: if the observation is already selected, don't select again.
+    '''Generates screen to select observation.
+    It reterives list of observations from database and make a table from that.
+    User has to select observation with dataset_id, parameter_id.
+    If the size of terminal screen is small to show whole table, a notification with link to parameter table on website will show up instead.
+
+    :param header: Header of page
+    :type header: string
+
+    :returns: Notification
+    :rtype: string
+    '''
+
+    ready_screen("select_obs_screen")
+    screen.addstr(1, 1, header + " > Select Observation ")
+    screen.addstr(7, 1, "Observations Table: ")
+    screen.addstr(8, 2, "|D-ID| - |P-ID| - |Database")
+    screen.addstr(9, 2, "|----| - |----| - |--------")
+    all_obs_info = rcmed.get_parameters_metadata()
+    try:
+         for position, obs_info in enumerate(all_obs_info):
+              dataset_id = obs_info['dataset_id']
+              parameter_id = obs_info['parameter_id']
+              database = obs_info['database']
+              line = "|{0:>4}| - |{1:>4}| - |{2}".format(dataset_id, parameter_id, database)
+              if position <= 25:
+                   screen.addstr(10 + position, 2, line)
+              elif position > 25 and position <= 50:
+                   screen.addstr(8, 50, "|D-ID| - |P-ID| - |Database")
+                   screen.addstr(9, 50, "|----| - |----| - |--------")
+                   screen.addstr(10 + position - 26, 50, line)
+              else:
+                   screen.addstr(8, 100, "|D-ID| - |P-ID| - |Database")
+                   screen.addstr(9, 100, "|----| - |----| - |--------")
+                   screen.addstr(10 + position - 51, 100, line)
+    except:
+         ready_screen("select_obs_screen")
+         screen.addstr(1, 1, header + " > Select Observation ")
+         screen.addstr(10, 1, "Observation table cannot be shown due to small screen size. ")
+         screen.addstr(11, 1, "Please enlarge your screen and try again or refer to 'https://rcmes.jpl.nasa.gov/content/data-rcmes-database'. ")
+    try:
+         screen.addstr(2, 1, "More info for observation: https://rcmes.jpl.nasa.gov/content/data-rcmes-database")
+         screen.addstr(4, 2, "Enter Dataset ID (D-ID): ")
+         dataset_id = screen.getstr()
+         screen.addstr(5, 2, "Enter Parameter ID (P-ID): ")
+         parameter_id = screen.getstr()
+
+         for obs in all_obs_info:
+              if obs['dataset_id'] == dataset_id and obs['parameter_id'] == parameter_id:
+                   observations_info.append({
+                        'database':obs['database'],
+                        'dataset_id':dataset_id,
+                        'parameter_id':parameter_id,
+                        'start_date':obs['start_date'],
+                        'end_date':obs['end_date'],
+                        'bounding_box':obs['bounding_box'],
+                        'timestep':obs['timestep'],
+                        'min_lat':float(eval(obs['bounding_box'].encode())[2][0]) if obs['bounding_box'] else None,
+                        'max_lat':float(eval(obs['bounding_box'].encode())[0][0]) if obs['bounding_box'] else None,
+                        'min_lon':float(eval(obs['bounding_box'].encode())[2][1]) if obs['bounding_box'] else None,
+                        'max_lon':float(eval(obs['bounding_box'].encode())[0][1]) if obs['bounding_box'] else None,
+                        'lat_res':float(obs['lat_res'].encode()),
+                        'lon_res':float(obs['lon_res'].encode()),
+                        'unit':obs['units']
+                        })
+                   note = "Observation sucessfully selected."
+                   break
+              else:
+                   note = "WARNING: Observation cannot be selected. There is no observation with given info."
+    except:
+         note = "WARNING: Observation cannot be selected, dataset or parameter id is wrong."
+
+    return  note
+
+
+def load_esgf_obs_screen(header):
+    '''Generates screen to be able to load ESGF observation file.
+
+    :param header: Header of page
+    :type header: string
+
+    :returns: Notification
+    :rtype: string
+    '''
+
+    ready_screen("load_esgf_obs_screen")
+    screen.addstr(1, 1, header + " > Download ESGF Dataset ")
+    screen.addstr(6, 1, "Enter Dataset ID:")
+    esgf_dataset_id = screen.getstr()
+    screen.addstr(7, 1, "Enter Variable:")
+    esgf_variable = screen.getstr()
+    screen.addstr(8, 1, "Enter Username:")
+    esgf_username = screen.getstr()
+    screen.addstr(9, 1, "Enter Password:")
+    esgf_password = screen.getstr()
+    try:
+        solr_url = "http://esg-datanode.jpl.nasa.gov/esg-search/search?id={0}&variable={1}&format=application%2Fsolr%2Bjson".format(esgf_dataset_id, esgf_variable)
+        metadata_json = json.load(urllib2.urlopen(solr_url))
+        all_variables = metadata_json['response']['docs'][0]['variable']
+        variable_index = all_variables.index(esgf_variable)
+        if metadata_json['response']['docs'][0]["product"][0] == "observations":
+            screen.addstr(11, 4, "Variable Long Name: {0}".format(metadata_json['response']['docs'][0]['variable_long_name'][variable_index]))
+            screen.addstr(12, 4, "Start Date: {0}".format(metadata_json['response']['docs'][0]['datetime_start']))
+            screen.addstr(13, 4, "End Stop: {0}".format(metadata_json['response']['docs'][0]['datetime_stop']))
+            screen.addstr(14, 4, "Time Frequency: {0}".format(metadata_json['response']['docs'][0]['time_frequency']))
+            screen.addstr(15, 4, "Variable Units: {0}".format(metadata_json['response']['docs'][0]['variable_units'][variable_index]))
+            screen.addstr(16, 4, "East Degrees: {0}".format(metadata_json['response']['docs'][0]['east_degrees']))
+            screen.addstr(17, 4, "North Degrees: {0}".format(metadata_json['response']['docs'][0]['north_degrees']))
+            screen.addstr(18, 4, "South Degrees: {0}".format(metadata_json['response']['docs'][0]['south_degrees']))
+            screen.addstr(19, 4, "West Degrees: {0}".format(metadata_json['response']['docs'][0]['west_degrees']))
+            screen.addstr(22, 2, "Confirm:")
+            screen.addstr(23, 4, "0- No")
+            screen.addstr(24, 4, "1- Yes")
+            screen.addstr(25, 3, "Would you take this dataset:")
+            answer = screen.getstr()
+            if answer == "0":
+                note = "WARNING: ESGF observation file cannot be added."
+            elif answer == "1":
+                try:
+                    screen.addstr(27, 4, "Downloading dataset.....")
+                    screen.refresh()
+                    datasets = esgf.load_dataset(esgf_dataset_id,
+                                                esgf_variable,
+                                                esgf_username,
+                                                esgf_password)
+                    netCDF_name = get_esgf_netCDF_file_name(esgf_dataset_id, esgf_variable)
+                    netCDF_path = "/tmp/{0}".format(netCDF_name)
+                    obs_dataset = load_file(netCDF_path, esgf_variable)
+                    observations_info.append({
+                     'database':"{0}".format(netCDF_path),
+                     'dataset_id':"esgf".format(esgf_variable),
+                     'parameter_id':"{0}".format(esgf_variable),
+                     'start_date': obs_dataset.time_range()[0].strftime("%Y-%m-%d"),
+                     'end_date':obs_dataset.time_range()[1].strftime("%Y-%m-%d"),
+                     #'bounding_box':obs['bounding_box'],
+                     'timestep':"monthly",
+                     'min_lat':obs_dataset.spatial_boundaries()[0],
+                     'max_lat':obs_dataset.spatial_boundaries()[1],
+                     'min_lon':obs_dataset.spatial_boundaries()[2],
+                     'max_lon':obs_dataset.spatial_boundaries()[3],
+                     'lat_res':obs_dataset.spatial_resolution()[0],
+                     'lon_res':obs_dataset.spatial_resolution()[1],
+                     'unit':"{0}".format(metadata_json['response']['docs'][0]['variable_units'][1])
+                     })
+                    note = "Dataset successfully downloaded."
+                except:
+                    note = "WARNING: Dataset has not been downloaded."
+        else:
+            note = "The selected dataset is not Observation, please enter observation dataset."
+    except:
+        note = "WARNING: Something went wrong in downloading observation dataset from ESGF."
+
+    return  note
+
+
+def unselect_obs_screen(header):
+    '''Generates screen to be able to unselect observations.
+    Observations can be unselected by entering index allocated to them.
+
+    :param header: Header of page
+    :type header: string
+
+    :returns: Notification
+    :rtype: string
+    '''
+
+    ready_screen("unselect_obs_screen")
+    screen.addstr(1, 1, header + " > Unselect Observation ")
+    screen.addstr(6, 1, "List Observation(s):")
+    for i, obs_info in enumerate(observations_info):
+         screen.addstr(8 + i, 10, " [" + str(i) + "] : " + " Dataset ID: " + obs_info['dataset_id'] + " - Parameter ID: "+ obs_info['parameter_id'] + " - Database: "+ obs_info['database'])
+    screen.addstr(3, 2, "Select the observation to remove (press enter to go back): ")
+    try:
+         obs_remove_index = screen.getstr()
+         observations_info.pop(int(obs_remove_index))
+         note = "Observation sucessfully unselected."
+    except:
+         note = "WARNING: Unselecting model was not successful."
+
+    return note
+
+
+def list_obs_screen(header):
+    '''Generates screen to list observations.
+
+    :param header: Header of page
+    :type header: string
+    '''
+
+    ready_screen("list_obs_screen")
+    screen.addstr(1, 1, header + " > List Observation ")
+    screen.addstr(6, 6, "List of observation(s): ")
+    for i, obs_info in enumerate(observations_info):
+         screen.addstr(8 + i, 10, " [" + str(i) + "] : " + " Dataset ID: " + obs_info['dataset_id'] + " - Parameter ID: "+ obs_info['parameter_id'] + " - Database: "+ obs_info['database'])
+    screen.addstr(4, 4, "Return to Manage Observation (press Enter) :")
+    screen.getstr()
+
+
+def manage_obs_screen(header, note=""):
+    '''Generates Manage Observation screen.
+
+    :param header: Header of page
+    :type header: string
+    :param note: Notification, defult to empty string.
+    :type note: string
+    '''
+
+    option = ''
+    while option != '0':
+         ready_screen("manage_obs_screen", note)
+         screen.addstr(1, 1, header)
+         screen.addstr(4, 4, "1 - Select Observation")
+         screen.addstr(6, 4, "2 - Load ESGF Observation")
+         screen.addstr(8, 4, "3 - Unselect Observation")
+         screen.addstr(10, 4, "4 - List Observation")
+         screen.addstr(12, 4, "0 - Return to Main Menu")
+         screen.addstr(14, 2, "Select an option: ")
+         screen.refresh()
+
+         option = screen.getstr()
+         if option == '1':
+              note = select_obs_screen(header)
+         if option == '2':
+              note = load_esgf_obs_screen(header)
+         if option == '3':
+              note = unselect_obs_screen(header)
+         if option == '4':
+              list_obs_screen(header)
+              note = " "
+
+
+##############################################################
+#     Run Evaluation Screen
+##############################################################
+
+def run_screen(model_datasets, models_info, observations_info,
+               overlap_start_time, overlap_end_time, overlap_min_lat,
+               overlap_max_lat, overlap_min_lon, overlap_max_lon,
+               temp_grid_setting, spatial_grid_setting, reference_dataset, target_datasets, metric, working_directory, plot_title):
+    '''Generates screen to show running evaluation process.
+
+    :param model_datasets: list of model dataset objects
+    :type model_datasets: list
+    :param models_info: list of dictionaries that contain information for each model
+    :type models_info: list
+    :param observations_info: list of dictionaries that contain information for each observation
+    :type observations_info: list
+    :param overlap_start_time: overlap start time between model and obs start time
+    :type overlap_start_time: datetime
+    :param overlap_end_time: overlap end time between model and obs end time
+    :type overlap_end_time: float
+    :param overlap_min_lat: overlap minimum lat between model and obs minimum lat
+    :type overlap_min_lat: float
+    :param overlap_max_lat: overlap maximum lat between model and obs maximum lat
+    :type overlap_max_lat: float
+    :param overlap_min_lon: overlap minimum lon between model and obs minimum lon
+    :type overlap_min_lon: float
+    :param overlap_max_lon: overlap maximum lon between model and obs maximum lon
+    :type overlap_max_lon: float
+    :param temp_grid_setting: temporal grid option such as hourly, daily, monthly and annually
+    :type temp_grid_setting: string
+    :param spatial_grid_setting:
+    :type spatial_grid_setting: string
+    :param reference_dataset: dictionary of reference dataset
+    :type reference_dataset: dictionary
+    :param target_datasets: dictionary of all target datasets
+    :type target_datasets: dictionary
+    :param metric: name of selected metric
+    :type metric: string
+    :param working_directory: path to a directory for storring outputs
+    :type working_directory: string
+    :param plot_title: Title for plot
+    :type plot_title: string
+    '''
+    try:
+        target_datasets_ensemble = []
+        new_model_datasets = model_datasets[:]
+
+        option = None
+        if option != "0":
+             ready_screen("run_evaluation_screen")
+             y = screen.getmaxyx()[0]
+             screen.addstr(2, 2, "Evaluation started....")
+             screen.refresh()
+
+             screen.addstr(4, 4, "Retrieving data...")
+             screen.refresh()
+             obs_dataset = []
+             for i in range(len(observations_info)):
+                  if observations_info[i]['dataset_id'] == "esgf":
+                      obs_dataset.append(load_file(observations_info[i]['database'], observations_info[i]['parameter_id']))
+                  else:
+                      dataset_id = int(observations_info[i]['dataset_id'])
+                      parameter_id = int(observations_info[i]['parameter_id'])
+                      obs_dataset.append(rcmed.parameter_dataset(
+                          dataset_id,
+                          parameter_id,
+                          overlap_min_lat,
+                          overlap_max_lat,
+                          overlap_min_lon,
+                          overlap_max_lon,
+                          overlap_start_time,
+                          overlap_end_time))
+
+             screen.addstr(4, 4, "--> Data retrieved.")
+             screen.refresh()
+
+             EVAL_BOUNDS = Bounds(overlap_min_lat, overlap_max_lat, overlap_min_lon, overlap_max_lon, overlap_start_time, overlap_end_time)
+
+             screen.addstr(5, 4, "Temporally regridding...")
+             screen.refresh()
+             if temp_grid_setting.lower() == 'hourly':
+                  days = 0.5
+             elif temp_grid_setting.lower() == 'daily':
+                  days = 1
+             elif temp_grid_setting.lower() == 'monthly':
+                  days = 31
+             else:
+                  days = 365
+             for i in range(len(obs_dataset)):
+                  obs_dataset[i] = dsp.temporal_rebin(obs_dataset[i], timedelta(days))
+
+             for member, each_target_dataset in enumerate(new_model_datasets):
+                  new_model_datasets[member] = dsp.temporal_rebin(new_model_datasets[member], timedelta(days))
+                  new_model_datasets[member] = dsp.subset(EVAL_BOUNDS, new_model_datasets[member])
+             screen.addstr(5, 4, "--> Temporally regridded.")
+             screen.refresh()
+
+             screen.addstr(6, 4, "Spatially regridding...")
+             screen.refresh()
+             new_lats = np.arange(overlap_min_lat, overlap_max_lat, spatial_grid_setting)
+             new_lons = np.arange(overlap_min_lon, overlap_max_lon, spatial_grid_setting)
+             for i in range(len(obs_dataset)):
+                  obs_dataset[i] = dsp.spatial_regrid(obs_dataset[i], new_lats, new_lons)
+
+             for member, each_target_dataset in enumerate(new_model_datasets):
+                  new_model_datasets[member] = dsp.spatial_regrid(new_model_datasets[member], new_lats, new_lons)
+             screen.addstr(6, 4, "--> Spatially regridded.")
+             screen.refresh()
+
+             if metric == 'bias':
+                  for i in range(len(obs_dataset)):
+                       _, obs_dataset[i].values = utils.calc_climatology_year(obs_dataset[i])
+                       obs_dataset[i].values = np.expand_dims(obs_dataset[i].values, axis=0)
+
+                  for member, each_target_dataset in enumerate(new_model_datasets):
+                          _, new_model_datasets[member].values = utils.calc_climatology_year(new_model_datasets[member])
+                          new_model_datasets[member].values = np.expand_dims(new_model_datasets[member].values, axis=0)
+
+                  allNames = []
+
+                  for model in new_model_datasets:
+                          allNames.append(model.name)
+
+                  screen.addstr(7, 4, "Setting up metrics...")
+                  screen.refresh()
+                  mean_bias = metrics.Bias()
+                  pattern_correlation = metrics.PatternCorrelation()
+                  spatial_std_dev_ratio = metrics.StdDevRatio()
+                  screen.addstr(7, 4, "--> Metrics setting done.")
+                  screen.refresh()
+
+                  screen.addstr(8, 4, "Running evaluation.....")
+                  screen.refresh()
+                  if reference_dataset[:3] == 'obs':
+                       reference = obs_dataset[int(reference_dataset[-1])]
+                  if reference_dataset[:3] == 'mod':
+                       reference = obs_dataset[int(new_model_datasets[-1])]
+
+                  targets = []
+                  for target in target_datasets:
+                       if target[:3] == 'obs':
+                            targets.append(obs_dataset[int(target[-1])])
+                       if target[:3] == 'mod':
+                            targets.append(new_model_datasets[int(target[-1])])
+
+                  evaluation_result = evaluation.Evaluation(reference, targets, [mean_bias])
+                  evaluation_result.run()
+                  screen.addstr(8, 4, "--> Evaluation Finished.")
+                  screen.refresh()
+
+                  screen.addstr(9, 4, "Generating plots....")
+                  screen.refresh()
+                  rcm_bias = evaluation_result.results[:][0]
+                  new_rcm_bias = np.squeeze(np.array(evaluation_result.results))
+
+                  if not os.path.exists(working_directory):
+                       os.makedirs(working_directory)
+
+                  fname = working_directory + 'Bias_contour'
+                  plotter.draw_contour_map(new_rcm_bias, new_lats, new_lons, gridshape=(2, 5), fname=fname, subtitles=allNames, cmap='coolwarm_r')
+                  screen.addstr(9, 4, "--> Plots generated.")
+                  screen.refresh()
+                  screen.addstr(y-2, 1, "Press 'enter' to Exit: ")
+                  option = screen.getstr()
+
+             if metric == 'std':
+                  for i in range(len(obs_dataset)):
+                       _, obs_dataset[i].values = utils.calc_climatology_year(obs_dataset[i])
+                       obs_dataset[i].values = np.expand_dims(obs_dataset[i].values, axis=0)
+
+                  target_datasets_ensemble = dsp.ensemble(new_model_datasets)
+                  target_datasets_ensemble.name = "ENS"
+                  new_model_datasets.append(target_datasets_ensemble)
+
+                  for member, each_target_dataset in enumerate(new_model_datasets):
+                          _, new_model_datasets[member].values = utils.calc_climatology_year(new_model_datasets[member])
+                          new_model_datasets[member].values = np.expand_dims(new_model_datasets[member].values, axis=0)
+
+                  allNames = []
+
+                  for model in new_model_datasets:
+                          allNames.append(model.name)
+                  pattern_correlation = metrics.PatternCorrelation()
+                  spatial_std_dev = metrics.StdDevRatio()
+
+                  if reference_dataset[:3] == 'obs':
+                       reference = obs_dataset[int(reference_dataset[-1])]
+                  if reference_dataset[:3] == 'mod':
+                       reference = obs_dataset[int(new_model_datasets[-1])]
+
+                  targets = []
+                  for target in target_datasets:
+                       if target[:3] == 'obs':
+                            targets.append(obs_dataset[int(target[-1])])
+                       if target[:3] == 'mod':
+                            targets.append(new_model_datasets[int(target[-1])])
+
+                  evaluation_result = evaluation.Evaluation(reference, targets, [spatial_std_dev])
+                  evaluation_result.run()
+
+                  rcm_std_dev = evaluation_result.results
+                  evaluation_result = evaluation.Evaluation(reference, targets, [pattern_correlation])
+                  evaluation_result.run()
+
+                  rcm_pat_cor = evaluation_result.results
+                  taylor_data = np.array([rcm_std_dev, rcm_pat_cor]).transpose()
+                  new_taylor_data = np.squeeze(np.array(taylor_data))
+
+                  if not os.path.exists(working_directory):
+                       os.makedirs(working_directory)
+
+                  fname = working_directory + 'taylor_plot'
+
+                  plotter.draw_taylor_diagram(new_taylor_data, allNames, "CRU31", fname=fname, fmt='png', frameon=False)
+        del new_model_datasets
+        del obs_dataset
+        return "No error"
+    except Exception, error:
+         return "Error: {0}".format(error[0][:200])
+
+
+##############################################################
+#     Settings Screen
+##############################################################
+
+def get_models_temp_bound():
+    '''Get models temporal bound.
+
+    :returns: model start and end time
+    :rtypes: (datatime, datetime)
+    '''
+
+    models_start_time = []
+    models_end_time = []
+    for model in model_datasets:
+         models_start_time.append(model.time_range()[0])
+         models_end_time.append(model.time_range()[1])
+
+    return models_start_time, models_end_time
+
+
+def get_obs_temp_bound():
+    '''Get observation temporal bound.
+
+    :returns: observation start and end time
+    :rtype: (datetime, datetime)
+    '''
+
+    observations_start_time = []
+    observations_end_time = []
+    for obs in observations_info:
+         obs_start_time = datetime.strptime(obs['start_date'], "%Y-%m-%d")
+         observations_start_time.append(obs_start_time)
+         obs_end_time = datetime.strptime(obs['end_date'], "%Y-%m-%d")
+         observations_end_time.append(obs_end_time)
+
+    return observations_start_time, observations_end_time
+
+
+def get_models_temp_overlap(models_start_time, models_end_time):
+    '''Calculate temporal overlap between all the models
+
+    :param models_start_time: models start time
+    :type models_start_time: list of datetimes
+    :param models_end_time: models end time
+    :type models_end_time: list of datetime
+
+    :returns: overlap start and end time between all the models
+    :rtype: (datetime, datetime)
+    '''
+
+    models_overlap_start_time = max(models_start_time)
+    models_overlap_end_time = min(models_end_time)
+
+    #Need to check if all models have temporal overlap, otherwise return
+    # to main menu and print a warning as notification.
+    if models_overlap_end_time <= models_overlap_start_time:
+         main_menu(model_datasets, models_info, observation_datasets, observations_info, note="WARNING: One or more model does not have temporal overlap with others.")
+
+    return models_overlap_start_time, models_overlap_end_time
+
+
+def get_obs_temp_overlap(observations_start_time, observations_end_time):
+    '''Calculate temporal overlap between all the observations
+
+    :param observations_start_time: observations start time
+    :type observations_start_time: list of datetimes
+    :param observations_end_time: observations end time
+    :type observations_end_time: list of datetime
+
+    :returns: overlap start and end time between all the observations
+    :rtype: (datetime, datetime)
+    '''
+
+    obs_overlap_start_time = max(observations_start_time)
+    obs_overlap_end_time = min(observations_end_time)
+
+    #Need to check if all observations have temporal overlap, otherwise return
+    # to main menu and print a warning as notification.
+    if obs_overlap_end_time <= obs_overlap_start_time:
+         main_menu(model_datasets, models_info, observation_datasets, observations_info, note="WARNING: One or more observation does not have temporal overlap with others.")
+
+    return obs_overlap_start_time, obs_overlap_end_time
+
+
+def get_all_temp_overlap(models_overlap_start_time, models_overlap_end_time, obs_overlap_start_time, obs_overlap_end_time):
+    '''Calculate temporal overlap between given datasets.
+
+    :param models_overlap_start_time: models overlap start time
+    :type models_overlap_start_time: list of datetimes
+    :param models_overlap_end_time: models overlap end time
+    :type models_overlap_end_time: list of datetime
+    :param obs_overlap_start_time: obs overlap start time
+    :type obs_overlap_start_time: list of datetimes
+    :param obs_overlap_end_time: obs overlap end time
+    :type obs_overlap_end_time: list of datetimes
+
+    :returns: overlap start and end time between models and observations
+    :rtype: (datetime, datetime)
+    '''
+
+    all_overlap_start_time = max([models_overlap_start_time, obs_overlap_start_time])
+    all_overlap_end_time = min([models_overlap_end_time, obs_overlap_end_time])
+
+    #Need to check if all datasets have temporal overlap, otherwise return
+    # to main menu and print a warning as notification.
+    if all_overlap_end_time <= all_overlap_start_time:
+         main_menu(model_datasets, models_info, observation_datasets, observations_info, note="WARNING: One or more dataset does not have temporal overlap with others.")
+
+    return all_overlap_start_time, all_overlap_end_time
+
+
+def get_models_spatial_bound():               #TODO: convert longitudes to -180, 180 to match with observation data
+    '''Get all models spatial bound.
+
+    :returns: all models spatial boundaries
+    :rtype: list
+    '''
+
+    models_bound = []
+    for model in model_datasets:
+         models_bound.append(model.spatial_boundaries())
+
+    return models_bound
+
+
+def get_models_spatial_overlap(models_bound):
+    '''Calculate spatial overlap between all models.
+
+    :param models_bound: all models spatial boundaries information
+    :type models_bound: list
+
+    :returns: spatial boundaries overlap between all models
+    :rtype: (float, float, float, float)
+    '''
+
+    models_overlap_min_lat = max(each[0] for each in models_bound)
+    models_overlap_max_lat = min(each[1] for each in models_bound)
+    models_overlap_min_lon = max(each[2] for each in models_bound)
+    models_overlap_max_lon = min(each[3] for each in models_bound)
+
+    #Need to check if all models have spatial overlap, otherwise return
+    # to main menu and print a warning as notification.
+    if models_overlap_max_lat <= models_overlap_min_lat or models_overlap_max_lon <= models_overlap_min_lon:
+         main_menu(model_datasets, models_info, observation_datasets, observations_info, note="WARNING: One or more model does not have spatial overlap with others.")
+
+    return models_overlap_min_lat, models_overlap_max_lat, models_overlap_min_lon, models_overlap_max_lon
+
+
+def get_obs_spatial_bound():
+    '''Get all observations spatial bound.
+
+    :returns: all observations spatial boundaries
+    :rtype: list
+    '''
+
+    observations_bound = []
+    for obs in observations_info:
+         observations_bound.append([obs['min_lat'], obs['max_lat'], obs['min_lon'], obs['max_lon']])
+
+    return observations_bound
+
+
+def get_obs_spatial_overlap(observations_bound):
+    '''Calculate spatial overlap between all observations.
+
+    :param observations_bound: all observations spatial boundaries information
+    :type observations_bound: list
+
+    :returns: spatial boundaries overlap between all observations
+    :rtype: (float, float, float, float)
+    '''
+
+    obs_overlap_min_lat = max(each[0] for each in observations_bound)
+    obs_overlap_max_lat = min(each[1] for each in observations_bound)
+    obs_overlap_min_lon = max(each[2] for each in observations_bound)
+    obs_overlap_max_lon = min(each[3] for each in observations_bound)
+
+    #Need to check if all observations have spatial overlap, otherwise return
+    # to main menu and print a warning as notification.
+    if obs_overlap_max_lat <= obs_overlap_min_lat or obs_overlap_max_lon <= obs_overlap_min_lon:
+         main_menu(model_datasets, models_info, observation_datasets, observations_info, note="WARNING: One or more observation does not have spatial overlap with others.")
+
+    return obs_overlap_min_lat, obs_overlap_max_lat, obs_overlap_min_lon, obs_overlap_max_lon
+
+
+def get_all_spatial_overlap(models_overlap_min_lat, models_overlap_max_lat, models_overlap_min_lon, models_overlap_max_lon, obs_overlap_min_lat, obs_overlap_max_lat, obs_overlap_min_lon, obs_overlap_max_lon):
+    '''Calculate spatial overlap between all models and observations
+
+    :param models_overlap_min_lat: min latitude between all models
+    :type models_overlap_min_lat: float
+    :param models_overlap_max_lat: max latitude between all models
+    :type models_overlap_max_lat: float
+    :param models_overlap_min_lon: min longitude between all models
+    :type models_overlap_min_lon: float
+    :param models_overlap_max_lon: max longitude between all models
+    :type models_overlap_max_lon: float
+    :param obs_overlap_min_lat: min latitude between all onservations
+    :type obs_overlap_min_lat: float
+    :param obs_overlap_max_lat: max latitude between all onservations
+    :type obs_overlap_max_lat: float
+    :param obs_overlap_min_lon: min longitude between all onservations
+    :type obs_overlap_min_lon: float
+    :param obs_overlap_max_lon: max longitude between all onservations
+    :type obs_overlap_max_lon: float
+
+    :returns: spatial boundaries overlap between all models and observations
+    :rtype: (float, float, float, float)
+    '''
+
+    all_overlap_min_lat = max([models_overlap_min_lat, obs_overlap_min_lat])
+    all_overlap_max_lat = min([models_overlap_max_lat, obs_overlap_max_lat])
+    all_overlap_min_lon = max([models_overlap_min_lon, obs_overlap_min_lon])
+    all_overlap_max_lon = min([models_overlap_max_lon, obs_overlap_max_lon])
+
+    #Need to check if all datasets have spatial overlap, otherwise return
+    # to main menu and print a warning as notification.
+    if all_overlap_max_lat <= all_overlap_min_lat or all_overlap_max_lon <= all_overlap_min_lon:
+         main_menu(model_datasets, models_info, observation_datasets, observations_info, note="WARNING: One or more dataset does not have spatial overlap with others.")
+
+    return all_overlap_min_lat, all_overlap_max_lat, all_overlap_min_lon, all_overlap_max_lon
+
+
+def get_models_temp_res():
+    '''Get models temporal resolution.
+
+    :returns: models resolution
+    :rtypes: string
+    '''
+
+    models_resolution = []
+    for model in model_datasets:
+         models_resolution.append(model.temporal_resolution())
+    dic = {0:"hourly", 1:"daily", 2:"monthly", 3:"yearly"}
+    models_resolution_key = []
+    for res in models_resolution:
+         for key, value in dic.items():
+              if value == res:
+                   models_resolution_key.append(key)
+
+    return dic[max(models_resolution_key)]
+
+
+def get_obs_temp_res():
+    '''Get observations temporal resolution.
+
+    :returns: observations resolution
+    :rtypes: string
+    '''
+
+    obs_resolution = []
+    for model in model_datasets:
+         obs_resolution.append(model.temporal_resolution())
+    dic = {0:"hourly", 1:"daily", 2:"monthly", 3:"yearly"}
+    obs_resolution_key = []
+    for res in obs_resolution:
+         for key, value in dic.items():
+              if value == res:
+                   obs_resolution_key.append(key)
+
+    return dic[max(obs_resolution_key)]
+
+
+def get_models_spatial_res():
+    '''Get models spatial resolution
+
+    :returns: maximum models latitude and longitude resolution
+    :rtypes: float, float
+    '''
+
+    models_lat_res = []
+    models_lon_res = []
+    for model in model_datasets:
+         models_lat_res.append(model.spatial_resolution()[0])
+         models_lon_res.append(model.spatial_resolution()[1])
+
+    return max(models_lat_res), max(models_lon_res)
+
+
+def get_obs_spatial_res():
+    '''Get observations spatial resolution
+
+    :returns: maximum observations latitude and longitude resolution
+    :rtypes: float, float
+    '''
+
+    obs_lat_res = []
+    obs_lon_res = []
+    for obs in observations_info:
+         obs_lat_res.append(obs['lat_res'])
+         obs_lon_res.append(obs['lon_res'])
+
+    return max(obs_lat_res), max(obs_lon_res)
+
+
+def settings_screen(header):
+    '''Generates screen for settings before running evaluation.
+
+    :param header: Header of page
+    :type header: string
+    '''
+
+    note = " "
+    models_start_time, models_end_time = get_models_temp_bound()
+    models_overlap_start_time, models_overlap_end_time = get_models_temp_overlap(models_start_time, models_end_time)
+    observations_start_time, observations_end_time = get_obs_temp_bound()
+    obs_overlap_start_time, obs_overlap_end_time = get_obs_temp_overlap(observations_start_time, observations_end_time)
+    all_overlap_start_time, all_overlap_end_time = get_all_temp_overlap(models_overlap_start_time, models_overlap_end_time, obs_overlap_start_time, obs_overlap_end_time)
+    models_bound = get_models_spatial_bound()
+    models_overlap_min_lat, models_overlap_max_lat, models_overlap_min_lon, models_overlap_max_lon = get_models_spatial_overlap(models_bound)
+    observations_bound = get_obs_spatial_bound()
+    obs_overlap_min_lat, obs_overlap_max_lat, obs_overlap_min_lon, obs_overlap_max_lon = get_obs_spatial_overlap(observations_bound)
+    all_overlap_min_lat, all_overlap_max_lat, all_overlap_min_lon, all_overlap_max_lon = get_all_spatial_overlap(models_overlap_min_lat,
+                                                                                                                 models_overlap_max_lat,
+                                                                                                                 models_overlap_min_lon,
+                                                                                                                 models_overlap_max_lon,
+                                                                                                                 obs_overlap_min_lat,
+                                                                                                                 obs_overlap_max_lat,
+                                                                                                                 obs_overlap_min_lon,
+                                                                                                                 obs_overlap_max_lon)
+    model_temp_res = get_models_temp_res()
+    obs_temp_res = get_obs_temp_res()
+    model_lat_res, model_lon_res = get_models_spatial_res()
+    obs_lat_res, obs_lon_res = get_obs_spatial_res()
+
+    temp_grid_option = "Observation"
+    temp_grid_setting = obs_temp_res
+    spatial_grid_option = "Observation"
+    spatial_grid_setting = obs_lat_res
+    models_dict = {}
+
+    for i in enumerate(models_info):
+         models_dict['mod{0}'.format(i[0])] = models_info[i[0]]
+    obs_dict = {}
+    for i in enumerate(observations_info):
+         obs_dict['obs{0}'.format(i[0])] = observations_info[i[0]]
+
+    reference_dataset = 'obs0'
+    target_datasets = []
+    for i in range(len(model_datasets)):
+         target_datasets.append('mod{0}'.format(i))
+    subregion_path = None
+    metrics_dict = {'1':'bias', '2':'std'}
+    metric = 'bias'
+    plots = {'bias':"contour map", 'std':"taylor diagram, bar chart(coming soon)"}
+    working_directory = os.getcwd() + "/plots/"  #Default value of working directory set to "plots" folder in current directory
+    plot_title = '' #TODO: ask user about plot title or figure out automatically
+
+    fix_min_time = all_overlap_start_time
+    fix_max_time = all_overlap_end_time
+    fix_min_lat = all_overlap_min_lat
+    fix_max_lat = all_overlap_max_lat
+    fix_min_lon = all_overlap_min_lon
+    fix_max_lon = all_overlap_max_lon
+
+    option = ''
+    while option != '0':
+         y, x = ready_screen("settings_screen", note)
+         screen.addstr(1, 1, header)
+         screen.addstr(3, 1, "INFORMATION")
+         screen.addstr(4, 1, "===========")
+         screen.addstr(6, 2, "Number of model file:   {0}".format(str(len(model_datasets))))
+         screen.addstr(7, 2, "Number of observation:  {0}".format(str(len(observations_info))))
+         screen.addstr(8, 2, "Temporal Boundaries:")
+         screen.addstr(9, 5, "Start time = {0}".format(all_overlap_start_time))
+         screen.addstr(10, 5, "End time = {0}".format(all_overlap_end_time))
+         screen.addstr(11, 2, "Spatial Boundaries:")
+         screen.addstr(12, 5, "min-lat = {0}".format(all_overlap_min_lat))
+         screen.addstr(13, 5, "max-lat = {0}".format(all_overlap_max_lat))
+         screen.addstr(14, 5, "min-lon = {0}".format(all_overlap_min_lon))
+         screen.addstr(15, 5, "max-lon = {0}".format(all_overlap_max_lon))
+         screen.addstr(16, 2, "Temporal Resolution:")
+         screen.addstr(17, 5, "Model = {0}".format(model_temp_res))
+         screen.addstr(18, 5, "Observation = {0}".format(obs_temp_res))
+         screen.addstr(19, 2, "Spatial Resolution:")
+         screen.addstr(20, 5, "Model:")
+         screen.addstr(21, 10, "lat = {0}".format(model_lat_res))
+         screen.addstr(22, 10, "lon = {0}".format(model_lon_res))
+         screen.addstr(23, 5, "Observation:")
+         screen.addstr(24, 10, "lat = {0}".format(obs_lat_res))
+         screen.addstr(25, 10, "lon = {0}".format(obs_lon_res))
+         screen.addstr(26, 2, "Temporal Grid Option:  {0}".format(temp_grid_option))
+         screen.addstr(27, 2, "Spatial Grid Option:   {0}".format(spatial_grid_option))
+         screen.addstr(28, 2, "Reference Dataset: {0}".format(reference_dataset))
+         screen.addstr(29, 2, "Target Dataset/s: {0}".format([mod for mod in target_datasets]))
+         screen.addstr(30, 2, "Working Directory:")
+         screen.addstr(31, 5, "{0}".format(working_directory))
+         screen.addstr(32, 2, "Metric: {0}".format(metric))
+         screen.addstr(33, 2, "Plot: {0}".format(plots[metric]))
+
+         screen.addstr(3, x/2, "MODIFICATION and RUN")
+         screen.addstr(4, x/2, "====================")
+         screen.addstr(6, x/2, "1 - Change Temporal Boundaries")
+         screen.addstr(7, x/2, "2 - Change Spatial Boundaries")
+         screen.addstr(8, x/2, "3 - Change Temporal Gridding")
+         screen.addstr(9, x/2, "4 - Change Spatial Gridding")
+         screen.addstr(10, x/2, "5 - Change Reference dataset")
+         screen.addstr(11, x/2, "6 - Change Target dataset/s")
+         screen.addstr(12, x/2, "7 - Change Metric")
+         screen.addstr(13, x/2, "8 - Change Working Directory")
+         screen.addstr(14, x/2, "9 - Change Plot Title [Coming Soon....]")
+         screen.addstr(15, x/2, "10 - Save the processed data [Coming Soon....]")
+         screen.addstr(16, x/2, "11 - Show Temporal Boundaries")
+         screen.addstr(17, x/2, "12 - Show Spatial Boundaries")
+         screen.addstr(18, x/2, "0 - Return to Main Menu")
+         screen.addstr(20, x/2, "r - Run Evaluation")
+         screen.addstr(22, x/2, "Select an option: ")
+
+         screen.refresh()
+         option = screen.getstr()
+
+         if option == '1':
+              screen.addstr(25, x/2, "Enter Start Time [min time: {0}] (Format YYYY-MM-DD):".format(fix_min_time))
+              new_start_time = screen.getstr()
+              try:
+                   new_start_time = datetime.strptime(new_start_time, '%Y-%m-%d')
+                   new_start_time_int = int("{0}{1}".format(new_start_time.year, new_start_time.month))
+                   fix_min_time_int = int("{0}{1}".format(fix_min_time.year, fix_min_time.month))
+                   fix_max_time_int = int("{0}{1}".format(fix_max_time.year, fix_max_time.month))
+                   all_overlap_end_time_int = int("{0}{1}".format(all_overlap_end_time.year, all_overlap_end_time.month))
+                   if new_start_time_int < fix_min_time_int \
+                   or new_start_time_int > fix_max_time_int \
+                   or new_start_time_int > all_overlap_end_time_int:
+                        note = "Start time has not changed. "
+                   else:
+                        all_overlap_start_time = new_start_time
+                        note = "Start time has changed successfully. "
+              except:
+                   note = "Start time has not changed. "
+              screen.addstr(26, x/2, "Enter End Time [max time:{0}] (Format YYYY-MM-DD):".format(fix_max_time))
+              new_end_time = screen.getstr()
+              try:
+                   new_end_time = datetime.strptime(new_end_time, '%Y-%m-%d')
+                   new_end_time_int = int("{0}{1}".format(new_end_time.year, new_end_time.month))
+                   fix_min_time_int = int("{0}{1}".format(fix_min_time.year, fix_min_time.month))
+                   fix_max_time_int = int("{0}{1}".format(fix_max_time.year, fix_max_time.month))
+                   all_overlap_start_time_int = int("{0}{1}".format(all_overlap_start_time.year, all_overlap_start_time.month))
+                   if new_end_time_int > fix_max_time_int \
+                   or new_end_time_int < fix_min_time_int \
+                   or new_end_time_int < all_overlap_start_time_int:
+                        note = note + " End time has not changed. "
+                   else:
+                        all_overlap_end_time = new_end_time
+                        note = note + " End time has changed successfully. "
+              except:
+                   note = note + " End time has not changed. "
+
+         if option == '2':
+              screen.addstr(25, x/2, "Enter Minimum Latitude [{0}]:".format(fix_min_lat))
+              new_min_lat = screen.getstr()
+              try:
+                   new_min_lat = float(new_min_lat)
+                   if new_min_lat < fix_min_lat or new_min_lat > fix_max_lat or new_min_lat > all_overlap_max_lat:
+                        note = "Minimum latitude has not changed. "
+                   else:
+                        all_overlap_min_lat = new_min_lat
+                        note = "Minimum latitude has changed successfully. "
+              except:
+                   note = "Minimum latitude has not changed. "
+              screen.addstr(26, x/2, "Enter Maximum Latitude [{0}]:".format(fix_max_lat))
+              new_max_lat = screen.getstr()
+              try:
+                   new_max_lat = float(new_max_lat)
+                   if new_max_lat > fix_max_lat or new_max_lat < fix_min_lat or new_max_lat < all_overlap_min_lat:
+                        note = note + " Maximum latitude has not changed. "
+                   else:
+                        all_overlap_max_lat = new_max_lat
+                        note = note + "Maximum latitude has changed successfully. "
+              except:
+                   note = note + " Maximum latitude has not changed. "
+              screen.addstr(27, x/2, "Enter Minimum Longitude [{0}]:".format(fix_min_lon))
+              new_min_lon = screen.getstr()
+              try:
+                   new_min_lon = float(new_min_lon)
+                   if new_min_lon < fix_min_lon or new_min_lon > fix_max_lon or new_min_lon > all_overlap_max_lon:
+                        note = note + " Minimum longitude has not changed. "
+                   else:
+                        all_overlap_min_lon = new_min_lon
+                        note = note + "Minimum longitude has changed successfully. "
+              except:
+                   note = note + " Minimum longitude has not changed. "
+              screen.addstr(28, x/2, "Enter Maximum Longitude [{0}]:".format(fix_max_lon))
+              new_max_lon = screen.getstr()
+              try:
+                   new_max_lon = float(new_max_lon)
+                   if new_max_lon > fix_max_lon or new_max_lon < fix_min_lon or new_max_lon < all_overlap_min_lon:
+                        note = note + " Maximum longitude has not changed. "
+                   else:
+                        all_overlap_max_lon = new_max_lon
+                        note = note + "Maximum longitude has changed successfully. "
+              except:
+                   note = note + " Maximum longitude has not changed. "
+
+         if option == '3':
+              screen.addstr(25, x/2, "Enter Temporal Gridding Option [Model or Observation]:")
+              new_temp_grid_option = screen.getstr()
+              if new_temp_grid_option.lower() == 'model':
+                   temp_grid_option = 'Model'
+                   temp_grid_setting = model_temp_res
+                   note = "Temporal gridding option has changed successfully to {0}".format(temp_grid_option)
+              elif new_temp_grid_option.lower() == 'observation':
+                   temp_grid_option = 'Observation'
+                   temp_grid_setting = obs_temp_res
+                   note = "Temporal gridding option has changed successfully to {0}".format(temp_grid_option)
+              else:
+                   note = "Temporal gridding option has not changed."
+
+         if option == '4':
+              screen.addstr(25, x/2, "Enter Spatial Gridding Option [Model, Observation or User]:")
+              new_spatial_grid_option = screen.getstr()
+              if new_spatial_grid_option.lower() == 'model':
+                   spatial_grid_option = 'Model'
+                   spatial_grid_setting = model_lat_res
+                   note = "Spatial gridding option has changed successfully to {0}".format(spatial_grid_option)
+              elif new_spatial_grid_option.lower() == 'observation':
+                   spatial_grid_option = 'Observation'
+                   spatial_grid_setting = obs_lat_res
+                   note = "Spatial gridding option has changed successfully to {0}".format(spatial_grid_option)
+              elif new_spatial_grid_option.lower() == 'user':
+                   screen.addstr(26, x/2, "Please enter spatial resolution: ")
+                   user_res = screen.getstr()
+                   try:
+                        user_res = float(user_res)
+                        spatial_grid_option = 'User: resolution {0}'.format(str(user_res))
+                        spatial_grid_setting = user_res
+                        note = "Spatial gridding option has changed successfully to {0}".format(spatial_grid_option)
+                   except:
+                        note = "Spatial gridding option has not changed."
+              else:
+                   note = "Spatial gridding option has not changed."
+
+         if option == '5':
+              screen.addstr(25, x/2, "Model/s:")
+              for each in enumerate(models_dict):
+                   screen.addstr(26 + each[0], x/2 + 2, "{0}: {1}".format(each[1], models_dict[each[1]]['directory'].split("/")[-1]))
+              screen.addstr(26 + len(models_dict), x/2, "Observation/s:")
+              for each in enumerate(obs_dict):
+                   screen.addstr(27 + len(models_dict) + each[0], x/2 + 2, "{0}: {1} - ({2})".format(each[1], obs_dict[each[1]]['database'], obs_dict[each[1]]['unit']))
+              screen.addstr(27 + len(obs_dict) + len(models_dict), x/2, "Please select reference dataset:")
+              selected_reference = screen.getstr()
+              if selected_reference in models_dict:
+                   reference_dataset = selected_reference
+                   note = "Reference dataset successfully changed."
+              elif selected_reference in obs_dict:
+                   reference_dataset = selected_reference
+                   note = "Reference dataset successfully changed."
+              else:
+                   note = "Reference dataset did not change."
+
+         if option == '6':
+              screen.addstr(25, x/2, "Model/s:")
+              for each in enumerate(models_dict):
+                   screen.addstr(26 + each[0], x/2 + 2, "{0}: {1}".format(each[1], models_dict[each[1]]['directory'].split("/")[-1]))
+              screen.addstr(26 + len(models_dict), x/2, "Observation/s:")
+              for each in enumerate(obs_dict):
+                   screen.addstr(27 + len(models_dict) + each[0], x/2 + 2, "{0}: {1} - ({2})".format(each[1], obs_dict[each[1]]['database'], obs_dict[each[1]]['unit']))
+              screen.addstr(27 + len(obs_dict) + len(models_dict), x/2, "Please enter target dataset/s (comma separated for multi target):")
+              selected_target = screen.getstr()
+              selected_target = selected_target.split(",")
+              if selected_target != ['']:
+                   target_datasets = []
+                   for target in selected_target:
+                        if target in models_dict:
+                             target_datasets.append(target)
+                             note = "Target dataset successfully changed."
+                        elif target in obs_dict:
+                             target_datasets.append(target)
+                             note = "Target dataset successfully changed."
+                        else:
+                             note = "Target dataset did not change."
+
+         if option == '7':
+              screen.addstr(25, x/2, "Available metrics:")
+              for i in enumerate(sorted(metrics_dict, key=metrics_dict.get)):
+                   screen.addstr(26 + i[0], x/2 + 2, "[{0}] - {1}".format(i[1], metrics_dict[i[1]]))
+              screen.addstr(26 + len(metrics_dict), x/2, "Please select a metric:")
+              metric_id = screen.getstr()
+              if metric_id in metrics_dict:
+                   metric = metrics_dict[metric_id]
+                   note = "Metric sucessfully changed to {0}".format(metric)
+              else:
+                   note = "Metric has not changes"
+
+         if option == '8':
+              screen.addstr(25, x/2, "Please enter working directory path:")
+              working_directory = screen.getstr()
+              if working_directory:
+                   if working_directory[-1] != '/':
+                        working_directory = working_directory + "/"
+              else:
+                   note = "Working directory has not changed"
+
+         if option == '9':
+              screen.addstr(25, x/2, "Please enter plot title:")
+              plot_title = screen.getstr()
+
+         #if option == '10':
+         #     screen.addstr(25, x/2, "Please enter plot title:")
+         #     plot_title = screen.getstr()
+
+         if option == '11':
+              models_start_time, models_end_time = get_models_temp_bound()
+              line = 25
+              for i, model in enumerate(model_datasets):
+                   mode_name = models_info[i]['directory'].split("/")[-1]
+                   line += 1
+                   screen.addstr(line, x/2, "{0}".format(mode_name))
+                   line += 1
+                   screen.addstr(line, x/2 + 3, "Start:{0} - End:{1}".format(models_start_time[i], models_end_time[i]))
+
+              observations_start_time, observations_end_time = get_obs_temp_bound()
+              for i, obs in enumerate(observations_info):
+                   line += 1
+                   screen.addstr(line, x/2, "{0}".format(observations_info[i]['database']))
+                   line += 1
+                   screen.addstr(line, x/2 + 3, "Start:{0} - End:{1}".format(observations_start_time[i], observations_end_time[i]))
+              screen.getstr()
+
+         if option == '12':
+              models_bound = get_models_spatial_bound()
+              line = 25
+              for i, model in enumerate(model_datasets):
+                   mode_name = models_info[i]['directory'].split("/")[-1]
+                   line += 1
+                   screen.addstr(line, x/2, "{0}".format(mode_name))
+                   line += 1
+                   screen.addstr(line, x/2 + 3, "{0}".format(models_bound[i]))
+
+              observations_bound = get_obs_spatial_bound()
+              for i, obs in enumerate(observations_info):
+                   line += 1
+                   screen.addstr(line, x/2, "{0}".format(observations_info[i]['database']))
+                   line += 1
+                   screen.addstr(line, x/2 + 3, "{0}".format(observations_bound[i]))
+              screen.getstr()
+
+         if option.lower() == 'r':
+              note = run_screen(model_datasets, models_info, observations_info, all_overlap_start_time, all_overlap_end_time, \
+                         all_overlap_min_lat, all_overlap_max_lat, all_overlap_min_lon, all_overlap_max_lon, \
+                         temp_grid_setting, spatial_grid_setting, reference_dataset, target_datasets, metric, working_directory, plot_title)
+
+
+##############################################################
+#     Main Menu Screen
+##############################################################
+
+def main_menu(model_datasets, models_info, observation_datasets, observations_info, note=""):
+    '''This function Generates main menu page.
+
+    :param model_datasets: list of model dataset objects
+    :type model_datasets: list
+    :param models_info: list of dictionaries that contain information for each model
+    :type models_info: list
+    :param observation_datasets: list of observation dataset objects
+    :type observation_datasets: list
+    :param observations_info: list of dictionaries that contain information for each observation
+    :type observations_info: list
+    '''
+
+    option = ''
+    while option != '0':
+         ready_screen("main_menu", note)
+         model_status = "NC" if len(model_datasets) == 0 else "C"     #NC (Not Complete), if there is no model added, C (Complete) if model is added
+         obs_status = "NC" if len(observations_info) == 0 else "C"    #NC (Not Complete), if there is no observation added, C (Complete) if observation is added
+         screen.addstr(1, 1, "Main Menu:")
+         screen.addstr(4, 4, "1 - Manage Model ({0})".format(model_status))
+         screen.addstr(6, 4, "2 - Manage Observation ({0})".format(obs_status))
+         screen.addstr(8, 4, "3 - Run")
+         screen.addstr(10, 4, "0 - EXIT")
+         screen.addstr(16, 2, "Select an option: ")
+         screen.refresh()
+         option = screen.getstr()
+
+         if option == '1':
+              header = "Main Menu > Manage Model"
+              manage_model_screen(header)
+         if option == '2':
+              header = "Main Menu > Manage Observation"
+              manage_obs_screen(header)
+         if option == '3':
+              if model_status == 'NC' or obs_status == 'NC':
+                   main_menu(model_datasets, models_info, observation_datasets, observations_info, note="WARNING: Please complete step 1 and 2 before 3.")
+              else:
+                   header = "Main Menu > Run"
+                   settings_screen(header)
+    curses.endwin()
+    sys.exit()
+
+
+if __name__ == '__main__':
+     TITLE = "Project Name"
+     ORGANIZATION = "Organization Name"
+     screen = curses.initscr()
+     model_datasets = []           #list of model dataset objects
+     models_info = []              #list of dictionaries that contain information for each model
+     observation_datasets = []     #list of observation dataset objects
+     observations_info = []        #list of dictionaries that contain information for each observation
+     main_menu(model_datasets, models_info, observation_datasets, observations_info)


Mime
View raw message