remove python

python/.ipynb_checkpoints/GPS_hexbin-checkpoint.ipynb

-{
- "cells": [],
- "metadata": {},
- "nbformat": 4,
- "nbformat_minor": 2
-}

python/.ipynb_checkpoints/get_deployments_alborex-checkpoint.ipynb

-{
- "cells": [],
- "metadata": {},
- "nbformat": 4,
- "nbformat_minor": 2
-}

python/.ipynb_checkpoints/netcdf2json-checkpoint.ipynb

-{
- "cells": [],
- "metadata": {},
- "nbformat": 4,
- "nbformat_minor": 2
-}

python/alborex_functions.py

-import os
-import numpy as np
-import netCDF4
-import matplotlib.pyplot as plt
-from mpl_toolkits.basemap import Basemap
-
-import six
-from six.moves import xrange
-
-import matplotlib
-import matplotlib.cm as cm
-import matplotlib.colors as mcolors
-import matplotlib.collections as mcollections
-import matplotlib.patches as patches
-from matplotlib.path import Path
-from matplotlib.offsetbox import AnnotationBbox, OffsetImage
-from matplotlib._png import read_png
-
-
-
-
-
-def add_logo(imagepath, ax, position, zoom, zorder):
-    """Add an image on the figure
-    :param imagepath: path to the image to add
-    :param ax: axes object
-    :param position: relative position on the map
-    :param zoom: zoom level
-    :param zorder:
-    :return:
-    """
-    logo2plot = read_png(imagepath)
-    imagebox = OffsetImage(logo2plot, zoom=zoom)
-    # coordinates to position this image
-
-    ab = AnnotationBbox(imagebox, position,
-                        xybox=(0., 0.),
-                        xycoords='data',
-                        pad=0.0,
-                        boxcoords="offset points")
-    ab.zorder = zorder
-    ax.add_artist(ab)
-
-
-def create_rect_patch(coordinates, m, **kwargs):
-    """
-    Create a rectangular patch to add on the map
-    :param coordinates:
-    :param m: Basemap object
-    :return: patch
-    """
-    xr1, yr1 = m(coordinates[0], coordinates[2])
-    xr2, yr2 = m(coordinates[0], coordinates[3])
-    xr3, yr3 = m(coordinates[1], coordinates[3])
-    xr4, yr4 = m(coordinates[1], coordinates[2])
-    verts = [(xr1, yr1), (xr2, yr2), (xr3, yr3), (xr4, yr4), (xr1, yr1), ]
-    codes = [Path.MOVETO, Path.LINETO, Path.LINETO,
-             Path.LINETO, Path.CLOSEPOLY, ]
-    path = Path(verts, codes)
-    patch = patches.PathPatch(path, **kwargs)
-    return patch
-
-
-def extract_coastline(coordinates, filename, res='i'):
-    """
-    Extract the coastline in a region delimited by a bounding box
-    and save the result in a text file
-    :param coordinates: coordinates delimiting a bounding box (lonmin, lonmax, latmin, latmax)
-    :param filename: name of the file where the coastline will be saved
-    :param res: resolution for the extraction
-    :return:
-    """
-    x, y = gshhs.get_coastline(xlim=[coordinates[0], coordinates[1]],
-                               ylim=[coordinates[2], coordinates[3]],
-                               res=res)
-    # Save the coastline
-    np.savetxt(filename, np.ma.vstack((x, y)).T)
-
-
-def load_coast(coastfile, valex=-999.):
-    """
-    Read coastline coordinates from an existing file
-    :param coastfile: name of the file containing the coastline
-    :param valex: exclusion value
-    :return: lon, lat
-    """
-    lon, lat = np.loadtxt(coastfile, usecols=(0, 1), unpack=True)
-    lon[lon == valex] = np.nan
-    lat[lat == valex] = np.nan
-    return lon, lat
-
-
-def load_coast_gshhs(coastfile, coordinates, valex=-999.):
-    """
-    Read coastline coordinates from an existing file in a region delimited
-    by a bounding box
-    :param coastfile: name of the file containing the coastline
-    :param coordinates: coordinates delimiting a bounding box (lonmin, lonmax, latmin, latmax)
-    :param valex: exclusion value
-    :return: lon, lat
-    """
-    lon, lat = np.loadtxt(coastfile, usecols=(0, 1), unpack=True)
-    goodcoord = np.where((lon >= coordinates[0]) & (lon <= coordinates[1]) &
-                         (lat >= coordinates[2]) & (lat <= coordinates[3]))[0]
-    goodcoord2 = np.where(np.logical_or((lon == valex), (lat == valex)))[0]
-    goodcoord = np.union1d(goodcoord, goodcoord2)
-    lon, lat = lon[goodcoord], lat[goodcoord]
-    lon[lon == valex] = np.nan
-    lat[lat == valex] = np.nan
-
-    return lon, lat
-
-
-def alborex_load_bathy(bathyfile, coordinates):
-    """
-    Load bathymetry from a netCDF file in a select region
-    delimited by a list of coordinates
-    :param bathyfile: name of the netCDF file
-    :param coordinates: coordinates delimiting a bounding box (lonmin, lonmax, latmin, latmax)
-    :return:
-    """
-    with netCDF4.Dataset( bathyfile, 'r') as nc:
-        lon = nc.variables['longitude'][:]
-        lat = nc.variables['latitude'][:]
-        depth = nc.variables['depth'][:]
-        # subset
-        goodlon = np.where(np.logical_and((lon >= coordinates[0]),
-                                          (lon <= coordinates[1])))[0]
-        goodlat = np.where(np.logical_and((lat >= coordinates[2]),
-                                          (lat <= coordinates[3])))[0]
-        lon = lon[goodlon]
-        lat = lat[goodlat]
-        depth = depth[goodlat, :]
-        depth = depth[:, goodlon]
-    return lon, lat, depth
-
-
-def load_altimetry(altimetryfile, coordinates):
-    """
-
-    :param altimetryfile:
-    :param coordinates: coordinates delimiting a bounding box (lonmin, lonmax, latmin, latmax)
-
-    :return:
-    """
-    with netCDF4.Dataset(altimetryfile, 'r') as nc:
-        lon = nc.variables['lon'][:] - 360.
-        lat = nc.variables['lat'][:]
-        u = np.squeeze(nc.variables['u'][:])
-        v = np.squeeze(nc.variables['v'][:])
-        # subset
-        goodlon = np.where(np.logical_and((lon >= coordinates[0]),
-                                          (lon <= coordinates[1])))[0]
-        goodlat = np.where(np.logical_and((lat >= coordinates[2]),
-                                          (lat <= coordinates[3])))[0]
-        lon = lon[goodlon]
-        lat = lat[goodlat]
-        u = u[goodlat, :]
-        u = u[:, goodlon]
-        v = v[goodlat, :]
-        v = v[:, goodlon]
-    return lon, lat, u, v
-
-
-def load_sst(sstfile, coordinates):
-    """Return the coordinates, the SST, the time and the satellite name,
-    given a data file and a list of coordinates delimiting a bounding box
-    :param sstfile: name of the netCDF4 file containing the data
-    :param coordinates: coordinates delimiting a bounding box (lonmin, lonmax, latmin, latmax)
-    :return:
-    """
-    with netCDF4.Dataset(sstfile, 'r') as nc:
-        lon = nc.variables['lon'][:]
-        lat = nc.variables['lat'][:]
-        timesst = nc.variables['time'][:]
-
-        # subset
-        goodlon = np.where(np.logical_and((lon >= coordinates[0]),
-                                          (lon <= coordinates[1])))[0]
-        goodlat = np.where(np.logical_and((lat >= coordinates[2]),
-                                          (lat <= coordinates[3])))[0]
-        lon = lon[goodlon]
-        lat = lat[goodlat]
-        sst = np.squeeze(nc.variables['mcsst'][:, goodlat, goodlon])
-        mask = nc.variables['lsmask'][:, goodlat, goodlon].squeeze()
-        sst = np.ma.masked_where(mask == 1, sst)
-
-        timesst *= 60.
-        sat = nc.satellite
-        sensor = nc.sensor_name
-        sensorsat = sensor.upper() + ' on ' + sat.upper()
-    return lon, lat, sst, timesst, sensorsat
-
-
-def load_sst_l2(filename):
-    """
-    Load the SST from netCDF L2 file obtained from
-    https://oceancolor.gsfc.nasa.gov
-    :param filename: name of the netCDF file
-    :return: lon, lat, sst, sstflag, sstyear, sstday
-    """
-    if os.path.exists(filename):
-        with netCDF4.Dataset(filename) as nc:
-            # Read platform
-            sat = nc.platform
-            # Read time information
-            # Assume all the measurements made the same day (and same year)
-            year = nc.groups['scan_line_attributes'].variables['year'][0]
-            day = nc.groups['scan_line_attributes'].variables['day'][0]
-            # Read coordinates
-            lon = nc.groups['navigation_data'].variables['longitude'][:]
-            lat = nc.groups['navigation_data'].variables['latitude'][:]
-            # Read geophysical variables
-            try:
-                sst = nc.groups['geophysical_data'].variables['sst'][:]
-                sstqual = nc.groups['geophysical_data'].variables['qual_sst'][:]
-            except KeyError:
-                sst = nc.groups['geophysical_data'].variables['sst4'][:]
-                sstqual = nc.groups['geophysical_data'].variables['qual_sst4'][:]
-    else:
-        lon, lat, sst, sstqual, year, day, sat = [], [], [], [], [], [], []
-    return lon, lat, sst, sstqual, year, day, sat
-
-
-def load_sst_l2_old(sstfile):
-    """
-    Load the SST from netCDF L2 file obtained from
-    https://oceancolor.gsfc.nasa.gov
-    :param sstfile: name of the netCDF file
-    :return: lon, lat, sst, sstflag, sstyear, sstday
-    """
-    if 'SST4' in sstfile:
-        sstname = 'Geophysical_Data_sst4'
-        sstflagname = 'Geophysical_Data_qual_sst4'
-    else:
-        sstname = 'Geophysical_Data_sst'
-        sstflagname = 'Geophysical_Data_qual_sst'
-
-    with netCDF4.Dataset(sstfile, 'r') as nc:
-        lon = nc.variables['Navigation_Data_longitude'][:]
-        lat = nc.variables['Navigation_Data_latitude'][:]
-        sst = nc.variables[sstname][:] * 0.005
-        sstflag = nc.variables[sstflagname][:]
-        sst = np.ma.masked_where(sstflag > 1, sst)
-        sstyear = nc.Start_Year
-        sstday = nc.Start_Day
-    return lon, lat, sst, sstflag, sstyear, sstday
-
-def plot_sst_leaflet(lon, lat, sst, figname, **kwargs):
-    m = Basemap(llcrnrlon=coordinates[0],
-                llcrnrlat=coordinates[2],
-                 urcrnrlon=coordinates[1],
-                 urcrnrlat=coordinates[3], resolution = 'l', epsg=3857)
-    llon, llat = m(lon, lat)
-    fig = plt.figure(frameon=False)
-    ax = fig.add_axes([0, 0, 1, 1])
-    m.pcolormesh(llon, llat, sst, **kwargs)
-    ax.axis('off')
-    #ax.set_xlim(lon.min(), lon.max())
-    #ax.set_ylim(lat.min(), lat.max())
-    f1 = plt.gca()
-    f1.axes.get_xaxis().set_ticks([])
-    f1.axes.get_yaxis().set_ticks([])
-    plt.savefig(figname, transparent=True,
-                bbox_inches='tight', pad_inches=0)
-    plt.close()
-
-
-def load_ctd(ctdfile):
-    """
-    Load the coordinates (lon, lat, depth), the temperature and chlorophyll concentration
-    from the selected netCDF file
-    :param ctdfile: name of the netCDF file
-    :return: lon, lat, depth, temp, chloro
-    """
-    with netCDF4.Dataset(ctdfile, 'r') as nc:
-        lon = nc.variables['LON'][:]
-        lat = nc.variables['LAT'][:]
-        depth = nc.variables['DEPTH'][:]
-        time = nc.variables['time'][:]
-        temp = nc.variables['WTR_TEM_01'][:]
-        chloro = nc.variables['CHLO'][:]
-        chloro = np.ma.masked_where(np.isnan(chloro), chloro)
-    return lon, lat, depth, time, temp, chloro
-
-
-def load_glider_data(gliderfile, NN=1):
-    """
-    Load the coordinates and the temperature from a glider file
-    :param gliderfile: name of the netCDF file
-    :param NN: sub-sampling factor (keep 1 out of NN measurements)
-    """
-    with netCDF4.Dataset(gliderfile, 'r') as nc:
-        lon = nc.variables['longitude'][::NN]
-        lat = nc.variables['latitude'][::NN]
-        depth = nc.variables['depth'][::NN]
-        temperature = nc.variables['temperature'][::NN]
-    return lon, lat, depth, temperature
-
-
-def load_glider_coord(gliderfile):
-    """
-    Load the coordinates from a glider file
-    :param gliderfile: name of the glider netCDF file
-    :return: lon: longitude
-    :return: lat: latitude
-    :return: depth: depth
-    :return: time: time
-    """
-    with netCDF4.Dataset(gliderfile, 'r') as nc:
-        lon = nc.variables['longitude'][:]
-        lat = nc.variables['latitude'][:]
-        depth = nc.variables['depth'][:]
-        time = nc.variables['time'][:]
-    return lon, lat, depth, time
-
-
-def change_wall_prop(ax, coordinates, depths, angles):
-    ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
-    ax.w_yaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
-    ax.w_zaxis.set_pane_color((1.0, 1.0, 1.0, 1.0))
-    ax.w_xaxis.gridlines.set_linestyles(':')
-    ax.w_yaxis.gridlines.set_linestyles(':')
-    ax.w_zaxis.gridlines.set_linestyles(':')
-    ax.view_init(angles[0], angles[1])
-    ax.set_xlim(coordinates[0], coordinates[1])
-    ax.set_ylim(coordinates[2], coordinates[3])
-    ax.set_zlim(depths[0], depths[1])
-    ax.set_zlabel('Depth (m)')
-
-    ax.set_zticks(np.arange(depths[0], depths[1] + 10, depths[2]))
-    ax.set_zticklabels(range(int(-depths[0]), -int(depths[1]) - 10, -int(depths[2])))
-
-
-def read_l2_wind(windfile, coordinates):
-    """
-    Read the L2 wind from a netCDF file
-    given a list of coordinates delimiting a bounding box
-    :param windfile: netCDF file containing the data
-    :param coordinates: coordinates delimiting a bounding box (lonmin, lonmax, latmin, latmax)
-    :return: lon, lat, uwind, vwind, windtime
-    """
-
-    # Open NetCDF file
-    with netCDF4.Dataset(windfile) as nc:
-        lon = nc.variables['lon'][:]
-        lat = nc.variables['lat'][:]
-        windspeed = nc.variables['wind_speed'][:]
-        winddirection = nc.variables['wind_dir'][:]
-        windtime = nc.variables['time'][:]
-
-    # Change longitudes
-    lon[lon > 180] -= 360.0
-
-    # Reduce dimensions
-    lon = lon.flatten()
-    lat = lat.flatten()
-    windspeed = windspeed.flatten()
-    winddirection = winddirection.flatten()
-
-    # Select sub-region and check if data inside the area of interest
-    goodlon = np.nonzero(np.logical_and(lon <= coordinates[1],
-                                        lon >= coordinates[0]))
-    goodlon = goodlon[0]
-
-    if goodlon.size != 0:
-        lat = lat[goodlon]
-        lon = lon[goodlon]
-        windspeed = windspeed[goodlon]
-        winddirection = -winddirection[goodlon] + 90.
-        goodlat = np.nonzero(np.logical_and(lat <= coordinates[3],
-                                            lat >= coordinates[2]))
-        goodlat = goodlat[0]
-        if goodlat.size != 0:
-            lat = lat[goodlat]
-            lon = lon[goodlat]
-            windspeed = windspeed[goodlat]
-            winddirection = winddirection[goodlat]
-
-            uwind = windspeed * np.cos(np.deg2rad(winddirection))
-            vwind = windspeed * np.sin(np.deg2rad(winddirection))
-            uwind = np.ma.masked_where(uwind == uwind.fill_value, uwind)
-            vwind = np.ma.masked_where(vwind == vwind.fill_value, vwind)
-            uwind.data[uwind.data == uwind.data.min()] = 0
-            vwind.data[vwind.data == vwind.data.min()] = 0
-        else:
-            # print 'No value in selected region'
-            # print ' '
-            lon, lat, uwind, vwind = [], [], [], []
-    else:
-        print("No value in selected region")
-        lon, lat, uwind, vwind = [], [], [], []
-
-    return lon, lat, uwind, vwind, windtime

python/alborexconfig.json

-{
-    "datafiles":{
-        "adcp": "/home/ctroupin/Data/Alborex/ADCP/dep0023_socib-rv_scb-rdi001_L1_2014-05.nc",
-        "ctd": "/home/ctroupin/Data/Alborex/CTD/dep0007_socib-rv_scb-sbe9002_L1_2014-05-25.nc",
-        "ctdlegs": ["/home/ctroupin/Data/Alborex/CTD/ctd_positions_Leg1.txt",
-                    "/home/ctroupin/Data/Alborex/CTD/ctd_positions_Leg2.txt"],
-        "gliders": ["/home/ctroupin/Data/Alborex/Gliders/dep0005_icoast00_ime-slcost000_L1_2014-05-25_data_dt.nc",
-                    "/home/ctroupin/Data/Alborex/Gliders/dep0012_ideep00_ime-sldeep000_L1_2014-05-25_data_dt.nc"],
-        "profilers": ["/home/ctroupin/Data/Alborex/Profilers/dep0001_profiler-drifter-arvora3001_ogs-arvora3001_L1_2014-05-25.nc",
-                      "/home/ctroupin/Data/Alborex/Profilers/dep0001_profiler-drifter-provbioll001_ogs-provbioll001_L1_2014-05-25.nc"],
-        "coast": "/home/ctroupin/Data/Alborex/Coastline/coastline_cartex_f3.txt",
-        "rv": "/home/ctroupin/Data/Alborex/RV/dep0015_socib-rv_scb-pos001_L1_2014-05-25.nc",
-        "altimetry": "/home/ctroupin/Data/Alborex/Altimetry/mean.nc",
-        "coast": "/home/ctroupin/Data/Alborex/Coastline/coastline_f.dat",
-        "thermosal": "/home/ctroupin/Data/Alborex/RV/dep0015_socib-rv_scb-tsl001_L1_2014-05-25_HR.nc"
-    },
-    "datadirs":{
-        "sst": "/home/ctroupin/Data/Alborex/SST/",
-        "drifters": "/home/ctroupin/Data/Alborex/Drifters",
-        "profilers": "/home/ctroupin/Data/Alborex/Profilers",
-        "adcp": "/home/ctroupin/Data/Alborex/ADCP"
-    },
-    "figdir": "/home/ctroupin/Publis/201703_AlborexData/figures",
-    "figdirleaflet": "/home/ctroupin/Publis/201703_AlborexData/leaflet/images/",
-    "domain":{
-        "coordinates1": [-6.75, 3.001, 34.75, 40.0],
-        "coordinates2": [-1.0, -0.25, 36.65, 37.25],
-        "coordinates3": [-6.0, -5.25, 35.8, 36.2],
-        "resolution1": [1.0, 1.0],
-        "resolution2": [0.25, 0.25]
-    }
-}

python/count_glider_profiles.ipynb

-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import glob\n",
-    "import netCDF4\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "3\n"
-     ]
-    }
-   ],
-   "source": [
-    "datadir = \"/home/ctroupin/Data/Alborex/Glider/\"\n",
-    "datafilelist = sorted(glob.glob(os.path.join(datadir, \"*nc\")))\n",
-    "nfiles = len(datafilelist)\n",
-    "print(nfiles)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Working on dep0005_icoast00_ime-slcost000_L1_2014-05-25_data_dt.nc\n",
-      "Number of profiles: 392.5\n",
-      "Number of profiles: 0.5\n",
-      "Working on dep0012_ideep00_ime-sldeep000_L1_2014-05-25_data_dt.nc\n",
-      "Number of profiles: 160.5\n",
-      "Number of profiles: 0.5\n",
-      "Working on dep0012_ideep00_ime-sldeep000_L2_2014-05-25_data_dt.nc\n",
-      "Number of profiles: 160.0\n",
-      "Number of profiles: 1.0\n"
-     ]
-    }
-   ],
-   "source": [
-    "for datafile in datafilelist:\n",
-    "    with netCDF4.Dataset(datafile) as nc:\n",
-    "        profiles = nc.variables[\"profile_index\"][:]\n",
-    "        print(\"Working on {}\".format(os.path.basename(datafile)))\n",
-    "        print(\"Number of profiles: {0}\".format(profiles.max()))\n",
-    "        print(\"Number of profiles: {0}\".format(profiles.min()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "392.5"
-      ]
-     },
-     "execution_count": 10,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "profiles.max()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2\n"
-     ]
-    }
-   ],
-   "source": [
-    "datadir2 = \"/home/ctroupin/Data/Alborex/Profilers/\"\n",
-    "datafilelist = sorted(glob.glob(os.path.join(datadir2, \"*nc\")))\n",
-    "nfiles = len(datafilelist)\n",
-    "print(nfiles)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Working on dep0001_profiler-drifter-arvora3001_ogs-arvora3001_L1_2014-05-25.nc\n",
-      "Number of profiles: 12\n",
-      "Working on dep0001_profiler-drifter-provbioll001_ogs-provbioll001_L1_2014-05-25.nc\n",
-      "Number of profiles: 71\n"
-     ]
-    }
-   ],
-   "source": [
-    "for datafile in datafilelist:\n",
-    "    with netCDF4.Dataset(datafile) as nc:\n",
-    "        time = nc.variables[\"time\"][:]\n",
-    "        print(\"Working on {}\".format(os.path.basename(datafile)))\n",
-    "        print(\"Number of profiles: {0}\".format(len(time)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "554"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "393+161"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Diva-python3.6",
-   "language": "python",
-   "name": "diva-python3.6"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

python/figure2_SatelliteData.ipynb

-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "import alborex_functions\n",
-    "import alborexdata\n",
-    "import netCDF4\n",
-    "import glob\n",
-    "import os\n",
-    "import json\n",
-    "import matplotlib.pyplot as plt\n",
-    "from mpl_toolkits.basemap import Basemap \n",
-    "import numpy as np\n",
-    "import datetime\n",
-    "import cmocean\n",
-    "from importlib import reload"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<module 'alborexdata' from '/home/ctroupin/Publis/201703_AlborexData/python/alborexdata.py'>"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "reload(alborexdata)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "import warnings\n",
-    "import matplotlib.cbook\n",
-    "warnings.filterwarnings(\"ignore\",category=matplotlib.cbook.mplDeprecation)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Configuration"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "with open('alborexconfig.json') as json_data_file:\n",
-    "    config = json.load(json_data_file)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "makeFigs, makeFigsLeaflet = 1, 0"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create a logger"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "logger = alborexdata.configure_logging(\"./logs/alborexFigure2.log\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Domain"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "coordinates = config[\"domain\"][\"coordinates1\"]\n",
-    "coordinates2 = config[\"domain\"][\"coordinates2\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create a list of netCDF files containing SST"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2018-08-28 10:30:04,652 - alborex_logger - INFO - Working on 2 SST files\n"
-     ]
-    }
-   ],
-   "source": [
-    "coastfile = config[\"datafiles\"][\"coast\"]\n",
-    "sstfilelist = sorted(glob.glob(os.path.join(config[\"datadirs\"][\"sst\"], '*SST*.nc')))\n",
-    "nfiles = len(sstfilelist)\n",
-    "if nfiles == 0:\n",
-    "    logger.warning(\"No SST files in directory {0}\".format(sstdir))\n",
-    "else:\n",
-    "    logger.info(\"Working on {0} SST files\".format(nfiles))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "cmap = plt.cm.RdYlBu_r"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Data reading and plotting\n",
-    "\n",
-    "Make figure directory if necessary."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2018-08-28 10:30:13,926 - alborex_logger - DEBUG - Figure directory /home/ctroupin/Publis/201703_AlborexData/figures already exists\n",
-      "2018-08-28 10:30:13,932 - alborex_logger - DEBUG - Figure directory /home/ctroupin/Publis/201703_AlborexData/leaflet/images/ already exists\n"
-     ]
-    }
-   ],
-   "source": [
-    "if os.path.isdir(config[\"figdir\"]):\n",
-    "    logger.debug(\"Figure directory {0} already exists\".format(config[\"figdir\"]))\n",
-    "else:\n",
-    "    os.makedirs(config[\"figdir\"])\n",
-    "    logger.debug(\"Creating figure directory {0}\".format(config[\"figdir\"]))\n",
-    "    \n",
-    "if os.path.isdir(config[\"figdirleaflet\"]):\n",
-    "    logger.debug(\"Figure directory {0} already exists\".format(config[\"figdirleaflet\"]))\n",
-    "else:\n",
-    "    os.makedirs(config[\"figdirleaflet\"])\n",
-    "    logger.debug(\"Creating figure directory {0}\".format(config[\"figdirleaflet\"]))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Coastline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "loncoast, latcoast = alborexdata.read_lonlat_coast(config[\"datafiles\"][\"coast\"])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Create the projection (only once)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "m = Basemap(projection='merc', llcrnrlon=coordinates[0], llcrnrlat=coordinates[2],\n",
-    "            urcrnrlon=coordinates[1], urcrnrlat=coordinates[3],\n",
-    "            lat_ts=0.5 * (coordinates[2] + coordinates[3]), resolution='h')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Projection for overlay in leaflet"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "m2 = Basemap(llcrnrlon=coordinates[0],\n",
-    "             llcrnrlat=coordinates[2],\n",
-    "             urcrnrlon=coordinates[1],\n",
-    "             urcrnrlat=coordinates[3], resolution = 'l', epsg=3857)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Front position"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "frontcoords = \"../data/front_coordinates.dat\"\n",
-    "f = alborexdata.Front()\n",
-    "f.get_from_file(frontcoords)\n",
-    "f.smooth()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Two plots on the same figure \n",
-    "Required by the journal"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2018-08-28 10:53:21,350 - alborex_logger - INFO - Working on file: A2014145125000.L2_LAC_SST.nc\n",
-      "2018-08-28 10:53:21,985 - alborex_logger - INFO - Working on file: A2014150020500.L2_LAC_SST.nc\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Rectangle for the region of interest\n",
-    "xrect = (coordinates2[0], coordinates2[1], coordinates2[1], coordinates2[0], coordinates2[0])\n",
-    "yrect = (coordinates2[2], coordinates2[2], coordinates2[3], coordinates2[3], coordinates2[2])\n",
-    "    \n",
-    "figname = \"fig02.png\"\n",
-    "fig = plt.figure(figsize=(10, 10))\n",
-    "\n",
-    "for ii, sstfiles in enumerate(sstfilelist):\n",
-    "    logger.info(\"Working on file: {0}\".format(os.path.basename(sstfiles)))\n",
-    "    \n",
-    "    # Read data from file\n",
-    "    lon, lat, sst, sstqual, year, day, platform = alborex_functions.load_sst_l2(sstfiles)\n",
-    "    \n",
-    "    # Create date from year and day\n",
-    "    titledate = (datetime.datetime(int(year), 1, 1) + datetime.timedelta(int(day) - 1)).strftime('%Y-%m-%d')\n",
-    "    figtitle = ' '.join(('MODIS', platform, '$-$', titledate))\n",
-    "    \n",
-    "    # Make the SST when flag > 1\n",
-    "    sst = np.ma.masked_where(sstqual > 1, sst)\n",
-    "\n",
-    "    ax = plt.subplot(2,1,ii+1)\n",
-    "    m.ax = ax\n",
-    "    pcm = m.pcolormesh(lon, lat, sst, latlon=True, \n",
-    "                       vmin=18., vmax=20.5, cmap=cmap)\n",
-    "\n",
-    "    # Add the coastline\n",
-    "    for i in range(0, len(loncoast)):\n",
-    "        m.plot(np.array(loncoast[i]), np.array(latcoast[i]), \n",
-    "               color='k', linewidth=.25, latlon=True)\n",
-    "\n",
-    "    alborexdata.add_map_grid(m, coordinates, dlon=2., dlat=2.,\n",
-    "                             fontname='Times New Roman', fontsize=14, \n",
-    "                             linewidth=0.2, zorder=1, color=\".6\")\n",
-    "\n",
-    "    m.drawmapscale(-.75, 35.25, -1, 35.25, 75, fontsize=12)\n",
-    "\n",
-    "    m.plot(xrect, yrect, \":\", color='k', latlon=True)\n",
-    "\n",
-    "    xtext1, ytext1 = m(-3.2, 37.)\n",
-    "    xfig1, yfig1 = m(coordinates2[0], coordinates2[2])\n",
-    "\n",
-    "    # Plot front\n",
-    "    m.plot(f.lon, f.lat, \"k--\", linewidth=2, latlon=True)\n",
-    "    ax.set_title(figtitle, fontsize=20)\n",
-    "\n",
-    "fig.subplots_adjust(right=0.95)\n",
-    "cbar_ax = fig.add_axes([0.85, 0.15, 0.035, 0.7])\n",
-    "cb = plt.colorbar(pcm, cax=cbar_ax, extend='both')\n",
-    "cb.set_label('$^{\\circ}$C', rotation=0, ha='left', fontsize=16)\n",
-    "cb.ax.tick_params(labelsize=14)\n",
-    "\n",
-    "# plt.show()\n",
-    "plt.savefig(os.path.join(config[\"figdir\"], figname), dpi=300, bbox_inches='tight')\n",
-    "plt.close()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Loop on the files"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2018-07-30 10:07:59,791 - alborex_logger - INFO - Working on file: A2014145125000.L2_LAC_SST.nc\n",
-      "2018-07-30 10:08:00,293 - alborex_logger - INFO - Making figure A2014145125000_L2_LAC_SST_cm.png\n",
-      "2018-07-30 10:08:04,481 - alborex_logger - INFO - Working on file: A2014146023000.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:08:04,928 - alborex_logger - INFO - Making figure A2014146023000_L2_LAC_SST4_cm.png\n",
-      "2018-07-30 10:08:08,735 - alborex_logger - INFO - Working on file: A2014147013500.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:08:09,137 - alborex_logger - INFO - Making figure A2014147013500_L2_LAC_SST4_cm.png\n",
-      "2018-07-30 10:08:12,756 - alborex_logger - INFO - Working on file: A2014148132000.L2_LAC_SST.nc\n",
-      "2018-07-30 10:08:13,172 - alborex_logger - INFO - Making figure A2014148132000_L2_LAC_SST_cm.png\n",
-      "2018-07-30 10:08:18,754 - alborex_logger - INFO - Working on file: A2014149012000.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:08:19,226 - alborex_logger - INFO - Making figure A2014149012000_L2_LAC_SST4_cm.png\n",
-      "2018-07-30 10:08:23,703 - alborex_logger - INFO - Working on file: A2014149122500.L2_LAC_SST.nc\n",
-      "2018-07-30 10:08:24,116 - alborex_logger - INFO - Making figure A2014149122500_L2_LAC_SST_cm.png\n",
-      "2018-07-30 10:08:27,975 - alborex_logger - INFO - Working on file: A2014150020500.L2_LAC_SST.nc\n",
-      "2018-07-30 10:08:28,396 - alborex_logger - INFO - Making figure A2014150020500_L2_LAC_SST_cm.png\n",
-      "2018-07-30 10:08:32,622 - alborex_logger - INFO - Working on file: A2014150020500.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:08:32,906 - alborex_logger - INFO - Making figure A2014150020500_L2_LAC_SST4_cm.png\n",
-      "2018-07-30 10:08:36,894 - alborex_logger - INFO - Working on file: T2014145111000.L2_LAC_SST.nc\n",
-      "2018-07-30 10:08:37,360 - alborex_logger - INFO - Making figure T2014145111000_L2_LAC_SST_cm.png\n",
-      "2018-07-30 10:08:41,215 - alborex_logger - INFO - Working on file: T2014145221500.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:08:41,734 - alborex_logger - INFO - Making figure T2014145221500_L2_LAC_SST4_cm.png\n",
-      "2018-07-30 10:08:45,844 - alborex_logger - INFO - Working on file: T2014146212000.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:08:46,258 - alborex_logger - INFO - Making figure T2014146212000_L2_LAC_SST4_cm.png\n",
-      "2018-07-30 10:08:50,637 - alborex_logger - INFO - Working on file: T2014149215000.L2_LAC_SST.nc\n",
-      "2018-07-30 10:08:51,090 - alborex_logger - INFO - Making figure T2014149215000_L2_LAC_SST_cm.png\n",
-      "2018-07-30 10:08:55,240 - alborex_logger - INFO - Working on file: T2014149215000.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:08:55,661 - alborex_logger - INFO - Making figure T2014149215000_L2_LAC_SST4_cm.png\n",
-      "2018-07-30 10:08:59,812 - alborex_logger - INFO - Working on file: T2014150113000.L2_LAC_SST.nc\n",
-      "2018-07-30 10:09:00,331 - alborex_logger - INFO - Making figure T2014150113000_L2_LAC_SST_cm.png\n",
-      "2018-07-30 10:09:04,373 - alborex_logger - INFO - Working on file: T2014150223500.L2_LAC_SST4.nc\n",
-      "2018-07-30 10:09:04,863 - alborex_logger - INFO - Making figure T2014150223500_L2_LAC_SST4_cm.png\n"
-     ]
-    }
-   ],
-   "source": [
-    "for sstfiles in sstfilelist:\n",
-    "    logger.info(\"Working on file: {0}\".format(os.path.basename(sstfiles)))\n",
-    "    \n",
-    "    # Read data from file\n",
-    "    lon, lat, sst, sstqual, year, day, platform = alborex_functions.load_sst_l2(sstfiles)\n",
-    "    \n",
-    "    # Create date from year and day\n",
-    "    titledate = (datetime.datetime(int(year), 1, 1) + datetime.timedelta(int(day) - 1)).strftime('%Y-%m-%d')\n",
-    "    figtitle = ' '.join(('MODIS', platform, '$-$', titledate))\n",
-    "    # logger.debug(title)\n",
-    "    \n",
-    "    # Make the SST when flag > 1\n",
-    "    sst = np.ma.masked_where(sstqual > 1, sst)\n",
-    "\n",
-    "    # Create figure name (remove .nc extension and substitute . by _)\n",
-    "    figname = ''.join(('_'.join(os.path.basename(sstfiles).split('.')[:-1]), '_cm.png'))\n",
-    "    logger.info(\"Making figure {0}\".format(figname))\n",
-    "    \n",
-    "    # Rectangle for the region of interest\n",
-    "    xrect = (coordinates2[0], coordinates2[1], coordinates2[1], coordinates2[0], coordinates2[0])\n",
-    "    yrect = (coordinates2[2], coordinates2[2], coordinates2[3], coordinates2[3], coordinates2[2])\n",
-    "    \n",
-    "    if makeFigs:\n",
-    "        # Normal figures\n",
-    "        fig = plt.figure(figsize=(10, 10))\n",
-    "        ax = plt.subplot(111)\n",
-    "        m.ax = ax\n",
-    "        pcm = m.pcolormesh(lon, lat, sst, latlon=True, \n",
-    "                           vmin=18., vmax=20.5, cmap=cmocean.cm.thermal)\n",
-    "\n",
-    "        # Add the contours\n",
-    "        for i in range(0, len(loncoast)):\n",
-    "            m.plot(np.array(loncoast[i]), np.array(latcoast[i]), \n",
-    "                   color='k', linewidth=.25, latlon=True)\n",
-    "\n",
-    "        alborexdata.add_map_grid(m, coordinates, dlon=2., dlat=2.,\n",
-    "                                 fontname='Times New Roman', fontsize=14, \n",
-    "                                 linewidth=0.2, zorder=1, color=\".6\")\n",
-    "\n",
-    "        #m.fillcontinents(color='w', zorder=2)\n",
-    "        #ax.set_xlim(coordinates[0], coordinates[1])\n",
-    "        #ax.set_ylim(coordinates[2], coordinates[3])\n",
-    "\n",
-    "        cb = plt.colorbar(pcm, extend='both', shrink=0.6)\n",
-    "        cb.set_label('$^{\\circ}$C', rotation=0, ha='left', fontsize=16)\n",
-    "        m.drawmapscale(-.75, 35.25, -1, 35.25, 75, fontsize=12)\n",
-    "        \n",
-    "        m.plot(xrect, yrect, \":\", color='.25', latlon=True)\n",
-    "\n",
-    "        xtext1, ytext1 = m(-3.2, 37.)\n",
-    "        xfig1, yfig1 = m(coordinates2[0], coordinates2[2])\n",
-    "        \n",
-    "        # Plot front\n",
-    "        m.plot(f.lon, f.lat, \"k--\", linewidth=2, latlon=True)\n",
-    "        \"\"\"\n",
-    "        ax.annotate(\"Region of interest\", xy=(xfig1, yfig1), \n",
-    "                    xytext=(xtext1, ytext1),\n",
-    "                    xycoords='data', textcoords='data', fontsize=16,\n",
-    "                    horizontalalignment=\"center\"\n",
-    "                   )\n",
-    "        \"\"\"\n",
-    "        \n",
-    "        plt.title(figtitle, fontsize=20)\n",
-    "        plt.savefig(os.path.join(config[\"figdir\"], figname), dpi=300, bbox_inches='tight')\n",
-    "        plt.close()\n",
-    "        \n",
-    "    if makeFigsLeaflet:\n",
-    "    \n",
-    "        # Figures without border and axes\n",
-    "        llon, llat = m2(lon, lat)\n",
-    "        fig = plt.figure(frameon=False)\n",
-    "        ax = fig.add_axes([0, 0, 1, 1])\n",
-    "        m2.pcolormesh(llon, llat, sst, vmin=17., vmax=20., cmap=cmap)\n",
-    "        ax.axis('off')\n",
-    "        #ax.set_xlim(lon.min(), lon.max())\n",
-    "        #ax.set_ylim(lat.min(), lat.max())\n",
-    "        f1 = plt.gca()\n",
-    "        f1.axes.get_xaxis().set_ticks([])\n",
-    "        f1.axes.get_yaxis().set_ticks([])\n",
-    "        plt.savefig(os.path.join(config[\"figdirleaflet\"], figname), transparent=True, \n",
-    "                    bbox_inches='tight', pad_inches=0)\n",
-    "        plt.close()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Diva-python3.6",
-   "language": "python",
-   "name": "diva-python3.6"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}