profile.py

# ===================================================================
# The contents of this file are dedicated to the public domain.  To
# the extent that dedication to the public domain is not available,
# everyone is granted a worldwide, perpetual, royalty-free,
# non-exclusive license to exercise all rights associated with the
# contents of this file for any purpose whatsoever.
# No rights are reserved.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# ===================================================================

'''
Created on Wed Sep 12 08:02:46 2012

The main application script for the NRCT. 

@author James Harle
@author John Kazimierz Farey
@author Srikanth Nagella
$Last commit on:$
'''

# pylint: disable=E1103
# pylint: disable=no-name-in-module

#External imports
import time
import logging
import numpy as np
from PyQt5.QtWidgets import QMessageBox
from calendar import monthrange
import sys

#Local imports
from pynemo import pynemo_settings_editor
from pynemo import nemo_bdy_ncgen as ncgen
from pynemo import nemo_bdy_ncpop as ncpop
from pynemo import nemo_bdy_source_coord as source_coord
from pynemo import nemo_bdy_dst_coord as dst_coord
from pynemo import nemo_bdy_setup as setup
from pynemo import nemo_bdy_gen_c as gen_grid
from pynemo import nemo_coord_gen_pop as coord
from pynemo import nemo_bdy_zgrv2 as zgrv
from pynemo import nemo_bdy_extr_tm3 as extract

from pynemo.reader.factory import GetFile
from pynemo.reader import factory
from pynemo.tide import nemo_bdy_tide3 as tide
from pynemo.tide import nemo_bdy_tide_ncgen
from pynemo.utils import Constants
from pynemo.gui.nemo_bdy_mask import Mask as Mask_File
from pynemo import nemo_bdy_dl_cmems as dl_cmems

class Grid(object):
    """ 
    A Grid object that stores bdy grid information
    """    
    def __init__(self):
        self.bdy_i       = None # bdy indices
        self.bdy_r       = None # associated rimwidth values
        self.grid_type   = None # this can be T/U/V
        self.fname_2     = None # 2nd file for vector rotation
        self.max_i       = None # length of i-axis in fname_2
        self.max_j       = None # length of j-axis in fname_2
        self.source_time = None # netcdftime information from parent files

logger = logging.getLogger(__name__)
logging.basicConfig(filename='nrct.log', level=logging.INFO)

def download_cmems(setup_filepath=0):
    '''
    CMEMS download function.

    This is the main script to download CMEMS data, it has been removed from core PyNEMO function
    to handle issues with downloading better e.g. connection issues etc.

    Input options are handled in the same NEMO style namelist that the main script uses.


    :param setup_filepath:
    :param mask_gui:
    :return:
    '''
    logger.info('============================================')
    logger.info('Start CMEMS download Logging: ' + time.asctime())
    logger.info('============================================')

    Setup = setup.Setup(setup_filepath)  # default settings file
    settings = Setup.settings
    if settings['download_static'] == False:
        logger.info('CMEMS static data download not requested')
    if settings['download_static'] == True:
        for re in range(settings['num_retry']):
            logger.info('CMEMS Static data requested: downloading static data now.... (this may take awhile)')
            static = dl_cmems.get_static(settings)
            if static == 0:
                logger.info('CMEMS static data downloaded')
                break
            if type(static) == str:
                err_chk = dl_cmems.err_parse(static,'FTP')
                if err_chk == 0:
                    logger.info('retrying FTP download....retry number '+str(re+1)+' of '+str(settings['num_retry']) )
                    if re == (settings['num_retry']-1):
                        logger.critical('reached retry limit defined in BDY file, exiting now')
                        logger.critical(static)
                        dl_cmems.clean_up(settings)
                        sys.exit(static)
                if err_chk == 1:
                    dl_cmems.clean_up(settings)
                    sys.exit(static)
                if err_chk == 2:
                    dl_cmems.clean_up(settings)
                    sys.exit(static)
        dl_cmems.clean_up(settings)

    # subset downloaded static grid files to match downloaded CMEMS data
    if settings['subset_static'] == False:
        logger.info('CMEMS subset static data not requested')
    if settings['subset_static'] == True:
        logger.info('CMEMS subset static data requested: subsetting now......')
        subset_static = dl_cmems.subset_static(settings)
        if subset_static == 0:
            logger.info('CMEMS static data subset successfully')
        if type(subset_static) == str:
            logger.error(subset_static)
            dl_cmems.clean_up(settings)
            sys.exit(subset_static)
        dl_cmems.clean_up(settings)

    if settings['download_cmems'] == False:
        logger.info('CMEMS Boundary data download not requested')

    if settings['download_cmems'] == True:

        logger.info('CMEMS Boundary data requested: starting download process....')

        if settings['year_end'] - settings['year_000'] > 0:
            date_min = str(settings['year_000']) + '-01-01'
            date_max = str(settings['year_end']) + '-12-31'

        elif settings['year_end'] - settings['year_000'] == 0:

            days_mth = monthrange(settings['year_end'], settings['month_end'])
            date_min = str(settings['year_000']) + '-' + str(settings['month_000']).zfill(2) + '-01'
            date_max = str(settings['year_end']) + '-' + str(settings['month_end']).zfill(2) + '-' + str(
                days_mth[1])

        elif settings['year_end'] - settings['year_000'] < 0:
            error_msg = 'end date before start date please ammend bdy file'
            logger.error(error_msg)
            dl_cmems.clean_up(settings)
            sys.exit(error_msg)
        else:
            logger.warning('unable to parse dates..... using demo date November 2017')
            date_min = '2017-11-01'
            date_max = '2017-11-30'
        # check to see if MOTU client is installed
        chk = dl_cmems.chk_motu()
        if chk == 1:
            error_msg = 'motuclient not installed, please install by running $ pip install motuclient'
            logger.error(error_msg)
            dl_cmems.clean_up(settings)
            sys.exit(error_msg)
        if type(chk) == str:
            logger.info('version ' + chk + ' of motuclient is installed')
        else:
            error_msg = 'unable to parse MOTU check'
            logger.error(error_msg)
            dl_cmems.clean_up(settings)
            sys.exit(error_msg)
        # download request for CMEMS data, try whole time interval first.
        for re in range(settings['num_retry']):
            logger.info('starting CMES download now (this can take a while)...')
            dl = dl_cmems.request_cmems(settings, date_min, date_max)
            if dl == 0:
                logger.info('CMES data downloaded successfully')
                break
            # a string return means MOTU has return an error
            if type(dl) == str:
            # check error message against logged errors
                err_chk = dl_cmems.err_parse(dl,'MOTU')
            # error is known and retry is likely to work
                if err_chk == 0:
                    logger.info('retrying CMEMS download....retry number '+str(re+1)+' of '+str(settings['num_retry']) )
                    if re == (settings['num_retry']-1):
                        logger.critical('reached retry limit defined in BDY file, exiting now')
                        logger.critical(dl)
                        dl_cmems.clean_up(settings)
                        sys.exit(dl)
            # error is known and retry is likely to not work
                if err_chk == 1:
                    dl_cmems.clean_up(settings)
                    sys.exit(dl)
            # error is not logged, add to error file.
                if err_chk == 2:
                    dl_cmems.clean_up(settings)
                    sys.exit(dl)
            if dl == 1:
                # if the request is too large try monthly intervals
                logger.warning('CMEMS request too large, try monthly downloads...(this may take awhile)')
                mnth_dl = dl_cmems.MWD_request_cmems(settings, date_min, date_max, 'M')
                if mnth_dl == 0:
                    logger.info('CMEMS monthly request successful')
                    break
                if type(mnth_dl) == str:
                    err_chk = dl_cmems.err_parse(mnth_dl,'MOTU')
                    if err_chk == 0:
                        logger.info('retrying CMEMS download....retry number '+str(re+1)+' of '+str(settings['num_retry']) )
                        if re == (settings['num_retry']-1):
                            logger.critical('reached retry limit defined in BDY file, exiting now')
                            logger.critical(mnth_dl)
                            dl_cmems.clean_up(settings)
                            sys.exit(mnth_dl)
                    if err_chk == 1:
                        dl_cmems.clean_up(settings)
                        sys.exit(mnth_dl)
                    if err_chk == 2:
                        dl_cmems.clean_up(settings)
                        sys.exit(mnth_dl)
                if mnth_dl == 1:
                    # if the request is too large try weekly intervals
                    logger.warning('CMEMS request still too large, trying weekly downloads...(this will take longer...)')
                    wk_dl = dl_cmems.MWD_request_cmems(settings, date_min, date_max, 'W')
                    if wk_dl == 0:
                        logger.info('CMEMS weekly request successful')
                        break
                    if type(wk_dl) == str:
                        err_chk = dl_cmems.err_parse(wk_dl,'MOTU')
                        if err_chk == 0:
                            logger.info('retrying CMEMS download....retry number ' + str(re + 1) + ' of ' + str(settings['num_retry']))
                            if re == (settings['num_retry'] - 1):
                                logger.critical('reached retry limit defined in BDY file, exiting now')
                                logger.critical(wk_dl)
                                dl_cmems.clean_up(settings)
                                sys.exit(wk_dl)
                        if err_chk == 1:
                            dl_cmems.clean_up(settings)
                            sys.exit(wk_dl)
                        if err_chk == 2:
                            dl_cmems.clean_up(settings)
                            sys.exit(wk_dl)
                    if wk_dl == 1:
                        # if the request is too large try daily intervals.
                        logger.warning('CMESM request STILL too large, trying daily downloads....(even longer.....)')
                        dy_dl = dl_cmems.MWD_request_cmems(settings, date_min, date_max, 'D')
                        if dy_dl == 0:
                            logger.info('CMEMS daily request successful')
                            break
                        # if the request is still too large then smaller domain is required.
                        if dy_dl == str:
                            # perform error check for retry
                            err_chk = dl_cmems.err_parse(dy_dl,'MOTU')
                            if err_chk == 0:
                                logger.info('retrying CMEMS download....retry number ' + str(re + 1) + ' of ' + str(settings['num_retry']))
                                if re == (settings['num_retry'] - 1):
                                    logger.critical('reached retry limit defined in BDY file, exiting now')
                                    logger.critical(dy_dl)
                                    dl_cmems.clean_up(settings)
                                    sys.exit(dy_dl)
                            if err_chk == 1:
                                dl_cmems.clean_up(settings)
                                sys.exit(dy_dl)
                            if err_chk == 2:
                                dl_cmems.clean_up(settings)
                                sys.exit(dy_dl)
# end of messy if statements to split requests into months, weeks and days as needed.
        dl_cmems.clean_up(settings)
    logger.info('============================================')
    logger.info('End CMEMS download: ' + time.asctime())
    logger.info('============================================')


def process_bdy(setup_filepath=0, mask_gui=False):
    """ 
    Main entry for processing BDY lateral boundary conditions.

    This is the main script that handles all the calls to generate open 
    boundary conditions for a given regional domain. Input options are handled 
    in a NEMO style namelist (namelist.bdy). There is an optional GUI allowing
    the user to create a mask that defines the extent of the regional model.

    Args:
        setup_filepath (str) : file path to find namelist.bdy
        mask_gui       (bool): whether use of the GUI is required

    """
    # Start Logger
    logger.info('============================================')
    logger.info('Start NRCT Logging: '+time.asctime())
    logger.info('============================================')
    
    SourceCoord = source_coord.SourceCoord()
    DstCoord    = dst_coord.DstCoord()

    Setup = setup.Setup(setup_filepath) # default settings file
    settings = Setup.settings

    logger.info('Reading grid completed')

    bdy_msk = _get_mask(Setup, mask_gui)
    DstCoord.bdy_msk = bdy_msk == 1
    
    logger.info('Reading mask completed')
    
    bdy_ind = {} # define a dictionary to hold the grid information
    
    for grd in ['t', 'u', 'v']:
        bdy_ind[grd] = gen_grid.Boundary(bdy_msk, settings, grd)
        logger.info('Generated BDY %s information', grd)
        logger.info('Grid %s has shape %s', grd, bdy_ind[grd].bdy_i.shape)

    # TODO: Write in option to seperate out disconnected LBCs
    
    # Write out grid information to coordinates.bdy.nc

    co_set = coord.Coord(settings['dst_dir']+'/coordinates.bdy.nc', bdy_ind)
    co_set.populate(settings['dst_hgr'])
    logger.info('File: coordinates.bdy.nc generated and populated')

    # Idenitify number of boundary points
    
    nbdy = {}
    
    for grd in ['t', 'u', 'v']:
        nbdy[grd] = len(bdy_ind[grd].bdy_i[:, 0])

    # Gather grid information
    
    # TODO: insert some logic here to account for 2D or 3D src_zgr
    
    logger.info('Gathering grid information')
    nc = GetFile(settings['src_zgr'])
    try:
        SourceCoord.zt = np.squeeze(nc['gdept_0'][:])
    except:
        SourceCoord.zt = np.squeeze(nc['depth'][:])
    nc.close()

    # Define z at t/u/v points

    z = zgrv.Depth(bdy_ind['t'].bdy_i,
                   bdy_ind['u'].bdy_i,
                   bdy_ind['v'].bdy_i, settings)

    # TODO: put conditional here as we may want to keep data on parent
    #       vertical grid
   
    DstCoord.depths = {'t': {}, 'u': {}, 'v': {}}

    for grd in ['t', 'u', 'v']:
        DstCoord.depths[grd]['bdy_H']  = np.nanmax(z.zpoints['w'+grd], axis=0)
        DstCoord.depths[grd]['bdy_dz'] = np.diff(z.zpoints['w'+grd], axis=0)
        DstCoord.depths[grd]['bdy_z']  = z.zpoints[grd]

    logger.info('Depths defined')
    
    # Gather vorizontal grid information
    # TODO: Sort generic grid variables (define in bdy file?)
    nc = GetFile(settings['src_hgr'])

    try:
        SourceCoord.lon = nc['glamt'][:,:]
        SourceCoord.lat = nc['gphit'][:,:]
    except:
        SourceCoord.lon = nc['longitude'][:]
        SourceCoord.lat = nc['latitude'][:]
        # expand lat and lon 1D arrays into 2D array matching nav_lat nav_lon
        SourceCoord.lon = np.tile(SourceCoord.lon, (np.shape(SourceCoord.lat)[0], 1))
        SourceCoord.lat = np.tile(SourceCoord.lat, (np.shape(SourceCoord.lon)[1], 1))
        SourceCoord.lat = np.rot90(SourceCoord.lat)
    
    try: # if they are masked array convert them to normal arrays
        SourceCoord.lon = SourceCoord.lon.filled()
    except:
        pass
    try:
        SourceCoord.lat = SourceCoord.lat.filled()
    except:
        pass
        
    nc.close()

    DstCoord.lonlat = {'t': {}, 'u': {}, 'v': {}}

    nc = GetFile(settings['dst_hgr'])

    # Read and assign horizontal grid data
    
    for grd in ['t', 'u', 'v']:
        DstCoord.lonlat[grd]['lon'] = nc['glam' + grd][0, :, :]
        DstCoord.lonlat[grd]['lat'] = nc['gphi' + grd][0, :, :]
    
    nc.close()

    logger.info('Grid coordinates defined')
    
    # Identify lons/lats of the BDY points
    
    DstCoord.bdy_lonlat = {'t': {}, 'u': {}, 'v': {}}
     
    for grd in ['t', 'u', 'v']:
        for l in ['lon', 'lat']:
            DstCoord.bdy_lonlat[grd][l] = np.zeros(nbdy[grd])

    for grd in ['t', 'u', 'v']:
        for i in range(nbdy[grd]):
            x = bdy_ind[grd].bdy_i[i, 1]
            y = bdy_ind[grd].bdy_i[i, 0]
            DstCoord.bdy_lonlat[grd]['lon'][i] =                              \
                                              DstCoord.lonlat[grd]['lon'][x, y]
            DstCoord.bdy_lonlat[grd]['lat'][i] =                              \
                                              DstCoord.lonlat[grd]['lat'][x, y]

        DstCoord.lonlat[grd]['lon'][DstCoord.lonlat[grd]['lon'] > 180] -= 360

    logger.info('BDY lons/lats identified from %s', settings['dst_hgr'])

    # Set up time information
    
    t_adj = settings['src_time_adj'] # any time adjutments?
    reader = factory.GetReader(settings['src_dir'],t_adj)
    for grd in ['t', 'u', 'v']:
        bdy_ind[grd].source_time = reader[grd]
 
    unit_origin = '%d-01-01 00:00:00' %settings['base_year']

    # Extract source data on dst grid

    if settings['tide']:
        if settings['tide_model']=='tpxo':
            cons = tide.nemo_bdy_tide_rot(
                Setup, DstCoord, bdy_ind['t'], bdy_ind['u'], bdy_ind['v'],
                                                            settings['clname'], settings['tide_model'])
        elif settings['tide_model']=='fes':
            cons = tide.nemo_bdy_tide_rot(
                Setup, DstCoord, bdy_ind['t'], bdy_ind['u'], bdy_ind['v'],
                                                            settings['clname'],settings['tide_model'])
            logger.warning('Tidal model: %s, not yet properly implimented',
                         settings['tide_model'])
        else:
            logger.error('Tidal model: %s, not recognised', 
                         settings['tide_model'])
            return
            
        write_tidal_data(Setup, DstCoord, bdy_ind, settings['clname'], cons)

    logger.info('Tidal constituents written to file')
    
    # Set the year and month range
    
    yr_000 = settings['year_000']
    yr_end = settings['year_end']
    mn_000 = settings['month_000']
    mn_end = settings['month_end']
    
    if yr_000 > yr_end:
        logging.error('Please check the nn_year_000 and nn_year_end '+ 
                      'values in input bdy file')
        return
    
    yrs = list(range(yr_000, yr_end+1))
    
    if yr_end - yr_000 >= 1:
        if list(range(mn_000, mn_end+1)) < 12:
            logger.info('Warning: All months will be extracted as the number '+
                        'of years is greater than 1')
        mns = list(range(1,13))
    else:
        mn_000 = settings['month_000']
        mn_end = settings['month_end']
        if mn_end > 12 or mn_000 < 1:
            logging.error('Please check the nn_month_000 and nn_month_end '+
                          'values in input bdy file')
            return
        mns = list(range(mn_000, mn_end+1))
    
    # Enter the loop for each year and month extraction
    
    logger.info('Entering extraction loop')
    
    ln_dyn2d   = settings['dyn2d']            
    ln_dyn3d   = settings['dyn3d'] # are total or bc velocities required
    ln_tra     = settings['tra']          
    ln_ice     = settings['ice']   

    # Define mapping of variables to grids with a dictionary
    
    emap = {}
    grd  = [  't',  'u',  'v']
    #pair = [ None, 'uv', 'uv'] # TODO: devolve this to the namelist?
    pair = [None, None, None]
    # TODO: The following is a temporary stop gap to assign variables for both CMEMS downloads
    #  and existing variable names. In future we need a slicker way of determining the variables to extract.
    # Perhaps by scraping the .ncml file - this way biogeochemical tracers
    # can be included in the ln_tra = .true. option without having to
    # explicitly declaring them.

    var_in = {}
    for g in range(len(grd)):
        var_in[grd[g]] = []
    if 'use_cmems' in settings:
        if settings['use_cmems'] == True:
            logger.info('using CMEMS variable names......')
            if ln_tra:
                var_in['t'].extend(['thetao'])
                #var_in['t'].extend(['so'])

            if ln_dyn2d or ln_dyn3d:
                var_in['u'].extend(['uo'])
                var_in['v'].extend(['vo'])

            if ln_dyn2d:
                var_in['t'].extend(['zos'])

            if ln_ice:
                var_in['t'].extend(['siconc', 'sithick'])

        if settings['use_cmems'] == False:
            logger.info('using existing PyNEMO variable names.....')
            if ln_tra:
                var_in['t'].extend(['votemper', 'vosaline'])

            if ln_dyn2d or ln_dyn3d:
                var_in['u'].extend(['vozocrtx'])
                var_in['v'].extend(['vomecrty'])

            if ln_dyn2d:
                var_in['t'].extend(['sossheig'])

            if ln_ice:
                var_in['t'].extend(['iicethic', 'ileadfra', 'isnowthi'])

    if 'use_cmems' not in settings:
        logger.info('using existing PyNEMO variable names.....')
        if ln_tra:
            var_in['t'].extend(['votemper', 'vosaline'])

        if ln_dyn2d or ln_dyn3d:
            var_in['u'].extend(['vozocrtx'])
            var_in['v'].extend(['vomecrty'])

        if ln_dyn2d:
            var_in['t'].extend(['sossheig'])

        if ln_ice:
            var_in['t'].extend(['iicethic', 'ileadfra', 'isnowthi'])
    
    # As variables are associated with grd there must be a filename attached
    # to each variable
    
    for g in range(len(grd)):
        
        if len(var_in[grd[g]])>0:
            emap[grd[g]]= {'variables': var_in[grd[g]],
                           'pair'     : pair[g]} 

    extract_obj = {}
    
    # Initialise the mapping indices for each grid 
    
    for key, val in list(emap.items()):
        
        extract_obj[key] = extract.Extract(Setup.settings, 
                                           SourceCoord, DstCoord,
                                           bdy_ind, val['variables'], 
                                           key, val['pair'])
    
    # TODO: Write the nearest neighbour parent grid point to each bdy point
    #       possibly to the coordinates.bdy.nc file to help with comparison
    #       plots later.
        
    for year in yrs:
        for month in mns:
            for key, val in list(emap.items()):
                
                # Extract the data for a given month and year
                
                extract_obj[key].extract_month(year, month)
                
                # Interpolate/stretch in time if time frequecy is not a factor 
                # of a month and/or parent:child calendars differ
                
                extract_obj[key].time_interp(year, month)
                
                # Finally write to file
                
                extract_obj[key].write_out(year, month, bdy_ind[key], 
                                           unit_origin)
                
    logger.info('End NRCT Logging: '+time.asctime())
    logger.info('==========================================')
                

def write_tidal_data(setup_var, dst_coord_var, grid, tide_cons, cons):
    """ 
    This method writes the tidal data to netcdf file.

    Args:
        setup_var     (list): Description of arg1
        dst_coord_var (obj) : Description of arg1
        grid          (dict): Description of arg1
        tide_cons     (list): Description of arg1
        cons          (data): Description of arg1
    """
    indx = 0
    
    # Mapping of variable names to grid types
    
    tmap = {}
    grd = ['t', 'u', 'v']
    var = ['z', 'u', 'v']
    des = ['tidal elevation components for:',
           'tidal east velocity components for:',
           'tidal north velocity components for:']
    
    for g in range(len(grd)):
        bdy_r = grid[grd[g]].bdy_r
        tmap[grd[g]]= {'nam': var[g], 'des': des[g], 
                       'ind': np.where(bdy_r == 0),
                       'nx' : len(grid[grd[g]].bdy_i[bdy_r == 0, 0])}
        
    # Write constituents to file
    
    for tide_con in tide_cons:
        
        const_name = setup_var.settings['clname'][tide_con]
        const_name = const_name.replace("'", "").upper()

        for key,val in list(tmap.items()):
            
            fout_tide = setup_var.settings['dst_dir']+             \
                        setup_var.settings['fn']+                  \
                        '_bdytide_'+const_name+'_grd_'+            \
                        val['nam'].upper()+'.nc'
            
            nemo_bdy_tide_ncgen.CreateBDYTideNetcdfFile(fout_tide, 
                            val['nx'], 
                            dst_coord_var.lonlat['t']['lon'].shape[1],
                            dst_coord_var.lonlat['t']['lon'].shape[0], 
                            val['des']+tide_con, 
                            setup_var.settings['fv'], key.upper())
            
            ncpop.write_data_to_file(fout_tide, val['nam']+'1', 
                                     cons['cos'][val['nam']][indx])
            ncpop.write_data_to_file(fout_tide, val['nam']+'2', 
                                     cons['sin'][val['nam']][indx])
            ncpop.write_data_to_file(fout_tide, 'bdy_msk',
                                     dst_coord_var.bdy_msk)
            ncpop.write_data_to_file(fout_tide, 'nav_lon',
                                     dst_coord_var.lonlat['t']['lon'])
            ncpop.write_data_to_file(fout_tide, 'nav_lat',
                                     dst_coord_var.lonlat['t']['lat'])
            ncpop.write_data_to_file(fout_tide, 'nbidta',
                                     grid[key].bdy_i[val['ind'], 0]+1)
            ncpop.write_data_to_file(fout_tide, 'nbjdta',
                                     grid[key].bdy_i[val['ind'], 1]+1)
            ncpop.write_data_to_file(fout_tide, 'nbrdta',
                                     grid[key].bdy_r[val['ind']]+1)
        
        # Iterate over constituents
        
        indx += 1

def _get_mask(Setup, mask_gui):
    """ 
    Read mask information from file or open GUI.

    This method reads the mask information from the netcdf file or opens a gui
    to create a mask depending on the mask_gui input. The default mask data 
    uses the bathymetry and applies a 1pt halo.

    Args:
        Setup    (list): settings for bdy
        mask_gui (bool): whether use of the GUI is required

    Returns:
        numpy.array     : a mask array of the regional domain
    """
    # Initialise bdy_msk array
    
    bdy_msk = None
    
    if mask_gui: # Do we activate the GUI
        
        # TODO: I do not like the use of _ for a dummy variable - better way?
        
        _, mask = pynemo_settings_editor.open_settings_dialog(Setup)
        bdy_msk = mask.data
        Setup.refresh()
        logger.info('Using GUI defined mask')
    else: # Try an read mask from file
        try:
            if (Setup.bool_settings['mask_file'] and 
                Setup.settings['mask_file'] is not None):
                mask = Mask_File(Setup.settings['bathy'], 
                                 Setup.settings['mask_file'])
                bdy_msk = mask.data
                logger.info('Using input mask file')
            elif Setup.bool_settings['mask_file']:
                logger.error('Mask file is not given')
                return
            else: # No mask file specified then use default 1px halo mask
                logger.warning('Using default mask with bathymetry!!!!')
                mask = Mask_File(Setup.settings['bathy'])
                mask.apply_border_mask(Constants.DEFAULT_MASK_PIXELS)
                bdy_msk = mask.data
        except:
            return
    
    if np.amin(bdy_msk) == 0: # Mask is not set, so set border to 1px
        logger.warning('Setting the mask to with a 1 grid point border')
        QMessageBox.warning(None,'NRCT', 'Mask is not set, setting a 1 grid '+
                                         'point border mask')
        if (bdy_msk is not None and 1 < bdy_msk.shape[0] and 
            1 < bdy_msk.shape[1]):
            tmp = np.ones(bdy_msk.shape, dtype=bool)
            tmp[1:-1, 1:-1] = False
            bdy_msk[tmp] = -1
            
    return bdy_msk