PrototypeDev.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dash\n",
    "from dash import dash_table\n",
    "import dash_html_components as html\n",
    "import dash_core_components as dcc\n",
    "import plotly.graph_objects as go\n",
    "import plotly.express as px\n",
    "import datetime\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import ETFunctions\n",
    "import matplotlib.dates as mdates\n",
    "import GraphHelpers as GH\n",
    "from bisect import bisect_left, bisect_right\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data extracted from CropData.cs InitialiseCropData() method\n",
    "CropCoefficients = pd.read_excel('C:\\\\GitHubRepos\\\\Overseer-testing\\\\CropCoefficients\\\\CropCoefficients.xlsx')\n",
    "CropCoefficients.set_index(['CropName'],inplace=True)\n",
    "Categories = CropCoefficients.Category.drop_duplicates().values\n",
    "CatFilt = (CropCoefficients.loc[:,'Category'] != 'Undefined') & (CropCoefficients.loc[:,'Category'] != 'Pasture')\n",
    "CropCoefficients = CropCoefficients.loc[CatFilt,:]\n",
    "\n",
    "LincolnMet = pd.read_csv('C:\\GitHubRepos\\Weather\\Broadfields\\LincolnClean.met',delimiter = '\\t')\n",
    "LincolnMet.name = 'Lincoln'\n",
    "GoreMet = pd.read_csv('C:\\GitHubRepos\\Weather\\OtherLocations\\GoreClean.met',delimiter = '\\t')\n",
    "GoreMet.name = 'Gore'\n",
    "WhatatuMet = pd.read_csv('C:\\GitHubRepos\\Weather\\OtherLocations\\WhatatuClean.met',delimiter = '\\t')\n",
    "WhatatuMet.name = 'Napier'\n",
    "PukekoheMet = pd.read_csv('C:\\GitHubRepos\\Weather\\OtherLocations\\PukekoheClean.met',delimiter = '\\t')\n",
    "PukekoheMet.name = 'Pukekohe'\n",
    "\n",
    "metFiles ={'Pukekohe':PukekoheMet,'Whatatu':WhatatuMet,'Lincoln':LincolnMet,'Gore':GoreMet}\n",
    "\n",
    "for f in metFiles.keys():\n",
    "    metFiles[f].loc[:,'Date'] = pd.to_datetime(metFiles[f].loc[:,'Date'])\n",
    "    metFiles[f].set_index('Date',inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9926084586557181\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Temperature accumulation')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "BiomassScaller = []\n",
    "Covers = []\n",
    "Xo_Biomass = 50\n",
    "b_Biomass = Xo_Biomass*0.2\n",
    "A_cov = 1\n",
    "T_mat = Xo_Biomass*2\n",
    "T_sen = T_mat-30\n",
    "Xo_cov = T_mat * 0.25\n",
    "b_cov = Xo_cov * 0.2\n",
    "Tts = range(150)\n",
    "for tt in Tts:\n",
    "    BiomassScaller.append(1/(1+np.exp(-((tt-Xo_Biomass)/(b_Biomass)))))\n",
    "    cover = 0\n",
    "    if tt < T_sen:\n",
    "        cover = A_cov * 1/(1+np.exp(-((tt-Xo_cov)/b_cov)))\n",
    "    else:\n",
    "        if tt < T_mat:\n",
    "            cover = A_cov * (1-(tt-T_sen)/(T_mat-T_sen))\n",
    "    Covers.append(cover)\n",
    "DMscaller = pd.DataFrame(index=Tts,data=BiomassScaller,columns=['scaller'])\n",
    "DMscaller.loc[:,'cover'] = Covers\n",
    "print(DMscaller.loc[99,'scaller'])\n",
    "plt.plot(DMscaller.loc[:,'scaller'])\n",
    "plt.plot(DMscaller.loc[:,'cover'])\n",
    "DMscaller.loc[:,'max'] = DMscaller.max(axis=1)\n",
    "\n",
    "Methods = ['Seed','Seedling','Vegetative','EarlyReproductive','LateReproductive','Maturity','Late']\n",
    "PrpnMaxDM = [0.0066,0.03,0.5,0.75,0.95,0.9933,0.9995]\n",
    "StagePropns = pd.DataFrame(index = Methods, data = PrpnMaxDM,columns=['PrpnMaxDM']) \n",
    "for p in StagePropns.index:\n",
    "    TTatProp = bisect_left(DMscaller.scaller,StagePropns.loc[p,'PrpnMaxDM'])\n",
    "    StagePropns.loc[p,'PrpnTt'] = TTatProp/T_mat\n",
    "    plt.plot(StagePropns.loc[p,'PrpnTt']*T_mat,StagePropns.loc[p,'PrpnMaxDM'],'o',color='k')\n",
    "    plt.text(StagePropns.loc[p,'PrpnTt']*T_mat+3,StagePropns.loc[p,'PrpnMaxDM'],p,verticalalignment='top')\n",
    "    plt.plot([StagePropns.loc[p,'PrpnTt']*T_mat]*2,[0,DMscaller.loc[round(StagePropns.loc[p,'PrpnTt'] * T_mat),'max']],'--',color='k',lw=1)\n",
    "plt.ylabel('Relative DM accumulation')\n",
    "plt.xlabel('Temperature accumulation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Xo_Biomass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CalcCovers(Tts, A_cov, Xo_cov, b_cov,T_sen,T_mat):\n",
    "    Covers = []\n",
    "    for tt in Tts:\n",
    "        cover = 0\n",
    "        if tt < T_sen:\n",
    "            cover = A_cov * 1/(1+np.exp(-((tt-Xo_cov)/b_cov)))\n",
    "        else:\n",
    "            if tt < T_mat:\n",
    "                cover = A_cov * (1-(tt-T_sen)/(T_mat-T_sen))\n",
    "        Covers.append(cover)\n",
    "    return Covers\n",
    "\n",
    "def CalcBiomass(Tts,Xo_Biomass,b_Biomass):\n",
    "    BiomassScaller = []\n",
    "    for tt in Tts:\n",
    "        BiomassScaller.append(1/(1+np.exp(-((tt-Xo_Biomass)/(b_Biomass)))))\n",
    "    return BiomassScaller    \n",
    "\n",
    "def NDilution(An,Bn,c,R):\n",
    "    return An * (1 + Bn * np.exp(c*R))\n",
    "\n",
    "def MakeDate(DateString,CheckDate):\n",
    "    Date = datetime.datetime(2000,int(datetime.datetime.strptime(DateString.split('-')[1],'%b').month),int(DateString.split('-')[0]))\n",
    "    if CheckDate == '':\n",
    "        CheckDate = datetime.datetime(2000,1,1)\n",
    "    if Date < CheckDate:\n",
    "        Date = datetime.datetime(2001,int(datetime.datetime.strptime(DateString.split('-')[1],'%b').month),int(DateString.split('-')[0]))\n",
    "    return Date\n",
    "\n",
    "def tt(x,b):\n",
    "    return max(0,x-b)\n",
    "\n",
    "def firstIndex(series,threshold):\n",
    "    pos=0\n",
    "    passed = False\n",
    "    while passed == False:\n",
    "        if series.iloc[pos] < threshold:\n",
    "            passed = True\n",
    "        pos +=1\n",
    "    return pos\n",
    "\n",
    "def DeriveParamsAndGraph(ax,Met,Establish,Harvest,EstablishStage,HarvestStage,totalN):\n",
    "    ## Calculate median thermaltime for location\n",
    "    FirstYear = int(Met.Year[0])\n",
    "    years = [int(x) for x in Met.Year.drop_duplicates().values[1:-1]]\n",
    "    day = int(Establish.split('-')[0])\n",
    "    month = datetime.datetime.strptime(Establish.split('-')[1],'%b').month\n",
    "    FirstDate = datetime.datetime(FirstYear,month,day)\n",
    "\n",
    "    Met.loc[:,'tt'] = [tt(x,5) for x in Met.Temp]\n",
    "    TT = pd.DataFrame(columns = years,index = range(1,368))\n",
    "    for y in years:\n",
    "        start = Establish + '-' + str(y)\n",
    "        end = Harvest + '-' + str(y+1)\n",
    "        duration = (datetime.datetime.strptime(end,'%d-%b-%Y') - datetime.datetime.strptime(start,'%d-%b-%Y')).days\n",
    "        try:\n",
    "            TT.loc[:,y] = Met.loc[start:,'tt'].cumsum().values[:367]\n",
    "        except:\n",
    "            do = 'nothing'\n",
    "    TTmed = (TT.median(axis=1))/30 # (TT.median(axis=1)-[5*x for x in TT.index])/30\n",
    "    TTmed.index = pd.date_range(start=Establish+'-2000',periods=367,freq='D',name='Date')\n",
    "    TTmed.name = 'Tt'\n",
    "\n",
    "    ## Calculate date variables\n",
    "    EstabDate = MakeDate(Establish,'')\n",
    "    HarvestDate = MakeDate(Harvest,EstabDate)\n",
    "    print(HarvestDate)\n",
    "\n",
    "    ## Calculate model parameters \n",
    "    Tt_Harv = TTmed[HarvestDate]\n",
    "    Tt_estab = Tt_Harv * (StagePropns.loc[EstablishStage,'PrpnTt']/StagePropns.loc[HarvestStage,'PrpnTt'])\n",
    "    Xo_Biomass = (Tt_Harv + Tt_estab) *.5 * (1/StagePropns.loc[HarvestStage,'PrpnTt'])\n",
    "    b_Biomass = Xo_Biomass * .2\n",
    "    # Calculate fitted patterns\n",
    "    CropPatterns = pd.DataFrame(TTmed+Tt_estab)\n",
    "    CropPatterns.loc[:,'biomass'] = CalcBiomass(CropPatterns.Tt.values,Xo_Biomass,b_Biomass) * 1/(StagePropns.loc[HarvestStage,'PrpnMaxDM']) * totalN\n",
    "    \n",
    "    CropPatterns = CropPatterns.iloc[:duration,:]\n",
    "    plt.plot(CropPatterns.index,CropPatterns.biomass,color='green')\n",
    "    #plt.plot(CropPatterns.index,CropPatterns.nitrogen)\n",
    "    ax.xaxis.set_major_locator(mdates.MonthLocator(interval=1))\n",
    "    ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n",
    "    plt.xlim(EstabDate,HarvestDate)\n",
    "    return CropPatterns\n",
    "    #plt.ylim(0,1.1)\n",
    "\n",
    "def MineralisationGraph(ax,Met,Establish,Harvest,EstablishStage,HarvestStage,p,col):\n",
    "    ## Calculate median thermaltime for location\n",
    "    FirstYear = int(Met.Year[0])\n",
    "    years = [int(x) for x in Met.Year.drop_duplicates().values[1:-1]]\n",
    "    day = int(Establish.split('-')[0])\n",
    "    month = datetime.datetime.strptime(Establish.split('-')[1],'%b').month\n",
    "    FirstDate = datetime.datetime(FirstYear,month,day)\n",
    "\n",
    "    Met.loc[:,'tt'] = [tt(x,5) for x in Met.Temp]\n",
    "    TT = pd.DataFrame(columns = years,index = range(1,368))\n",
    "    for y in years:\n",
    "        start = Establish + '-' + str(y)\n",
    "        end = Establish + '-' + str(y+1)\n",
    "        try:\n",
    "            TT.loc[:,y] = Met.loc[start:,'tt'].cumsum().values[:367]\n",
    "        except:\n",
    "            do = 'nothing'\n",
    "    TTmed = (TT.median(axis=1))/30 # (TT.median(axis=1)-[5*x for x in TT.index])/30\n",
    "    TTmed.index = pd.date_range(start=Establish+'-2000',periods=367,freq='D',name='Date')\n",
    "    TTmed.name = 'Tt'\n",
    "\n",
    "    ## Calculate date variables\n",
    "    EstabDate = MakeDate(Establish,'')\n",
    "    HarvestDate = MakeDate(Harvest,EstabDate)\n",
    "    Tt_Harv = TTmed[HarvestDate]\n",
    "    Tt_estab = Tt_Harv * (StagePropns.loc[EstablishStage,'PrpnTt']/StagePropns.loc[HarvestStage,'PrpnTt'])\n",
    "    CropPatterns = pd.DataFrame(TTmed+Tt_estab)\n",
    "    CropPatterns.loc[:,'biomass'] = CropPatterns.Tt.values * p\n",
    "    plt.plot(CropPatterns.index,CropPatterns.biomass,color=col)\n",
    "    #plt.plot(CropPatterns.index,CropPatterns.nitrogen)\n",
    "    ax.xaxis.set_major_locator(mdates.MonthLocator(interval=1))\n",
    "    ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n",
    "    plt.xlim(EstabDate,HarvestDate)\n",
    "    return CropPatterns.loc[:HarvestDate,'biomass'].max()\n",
    "    #plt.ylim(0,1.1)\n",
    "\n",
    "    \n",
    "def Deficit(ax,Met,Establish,Harvest,EstablishStage,HarvestStage,r,m,InitialN,FinalN,TotalCropN,splits,Eff):\n",
    "    ## Calculate median thermaltime for location\n",
    "    FirstYear = int(Met.Year[0])\n",
    "    years = [int(x) for x in Met.Year.drop_duplicates().values[1:-1]]\n",
    "    day = int(Establish.split('-')[0])\n",
    "    month = datetime.datetime.strptime(Establish.split('-')[1],'%b').month\n",
    "    FirstDate = datetime.datetime(FirstYear,month,day)\n",
    "\n",
    "    Met.loc[:,'tt'] = [tt(x,5) for x in Met.Temp]\n",
    "    TT = pd.DataFrame(columns = years,index = range(1,368))\n",
    "    for y in years:\n",
    "        start = Establish + '-' + str(y)\n",
    "        end = Harvest + '-' + str(y+1)\n",
    "        duration = (datetime.datetime.strptime(end,'%d-%b-%Y') - datetime.datetime.strptime(start,'%d-%b-%Y')).days\n",
    "        try:\n",
    "            TT.loc[:,y] = Met.loc[start:,'tt'].cumsum().values[:367]\n",
    "        except:\n",
    "            do = 'nothing'\n",
    "    TTmed = (TT.median(axis=1))/30 # (TT.median(axis=1)-[5*x for x in TT.index])/30\n",
    "    TTmed.index = pd.date_range(start=Establish+'-2000',periods=367,freq='D',name='Date')\n",
    "    TTmed.name = 'Tt'\n",
    "    ## Calculate date variables\n",
    "    EstabDate = MakeDate(Establish,'')\n",
    "    HarvestDate = MakeDate(Harvest,EstabDate)\n",
    "\n",
    "    ## Calculate model parameters \n",
    "    Tt_Harv = TTmed[HarvestDate]\n",
    "    Tt_estab = Tt_Harv * (StagePropns.loc[EstablishStage,'PrpnTt']/StagePropns.loc[HarvestStage,'PrpnTt'])\n",
    "    Xo_Biomass = (Tt_Harv + Tt_estab) *.5 * (1/StagePropns.loc[HarvestStage,'PrpnTt'])\n",
    "    b_Biomass = Xo_Biomass * .2\n",
    "\n",
    "    # Calculate fitted patterns\n",
    "    CropPatterns = pd.DataFrame(TTmed+Tt_estab)\n",
    "    CropPatterns.loc[:,'biomass'] = CalcBiomass(CropPatterns.Tt.values,Xo_Biomass,b_Biomass) * 1/(StagePropns.loc[HarvestStage,'PrpnMaxDM']) * TotalCropN\n",
    "    CropPatterns.loc[:,'residue'] = CropPatterns.Tt.values * r\n",
    "    CropPatterns.loc[:,'mineralisation'] = CropPatterns.Tt.values * m\n",
    "    CropPatterns.loc[:,'mineral'] = InitialN\n",
    "    CropPatterns = CropPatterns.iloc[:duration,:]\n",
    "    NFertReq = (CropPatterns.loc[:,'biomass'].max() + FinalN) - InitialN - CropPatterns.loc[:,'mineralisation'].max() - CropPatterns.loc[:,'residue'].max()\n",
    "    NFertReq = NFertReq * 1/Eff\n",
    "    NFertReq = np.ceil(NFertReq)\n",
    "    NAppn = NFertReq/splits\n",
    "    plength = duration/(splits + 1)\n",
    "    xlocs = [0]\n",
    "    plength = np.ceil(duration/(splits + 1))\n",
    "    xlocs = []\n",
    "    for x in range(1,int(splits+1)):\n",
    "        xlocs.append(x * plength)\n",
    "    FertApplied = 0\n",
    "    FertAppNo = 0\n",
    "    maxSoilN = max(InitialN,FinalN + NAppn)\n",
    "    for d in range(1,CropPatterns.index.size):\n",
    "        PotentialN = CropPatterns.iloc[d-1,4]+CropPatterns.iloc[:,2].diff()[d]+CropPatterns.iloc[:,3].diff()[d]-CropPatterns.iloc[:,1].diff()[d] \n",
    "        CropPatterns.iloc[d,4] = PotentialN\n",
    "        if (CropPatterns.iloc[d-1,4] > CropPatterns.iloc[d,4]) and (PotentialN < FinalN) and (FertApplied < NFertReq): #and ((CropPatterns.iloc[d-1,4]-CropPatterns.iloc[d,4])<0):\n",
    "            CropPatterns.iloc[d,4]  += NAppn * Eff\n",
    "            FertApplied += NAppn\n",
    "            plt.plot([CropPatterns.index[d]]*2,[CropPatterns.iloc[d-1,4],CropPatterns.iloc[d,4]],'-',color='k',lw=3)\n",
    "            recString = CropPatterns.index[d].strftime('%d-%b') +'\\n' +str(int(NAppn)) + ' kg/ha'\n",
    "            plt.text(CropPatterns.index[int(xlocs[FertAppNo])],maxSoilN*1.1,recString,fontsize=8,rotation=0,horizontalalignment='center',verticalalignment='bottom')\n",
    "            plt.arrow(CropPatterns.index[int(xlocs[FertAppNo])],maxSoilN*1.1,\n",
    "                      (CropPatterns.index[d]-CropPatterns.index[int(xlocs[FertAppNo])]).days,\n",
    "                      CropPatterns.iloc[d,4]-maxSoilN*1.1,\n",
    "                      length_includes_head = True,)\n",
    "            if FertAppNo == 0:\n",
    "                FirstFertDay = d\n",
    "            FertAppNo += 1\n",
    "    plt.text(0.02,0.05,'Total N Fert = ' + str(int(np.ceil(NFertReq))) + ' kg/ha',transform=ax.transAxes,horizontalalignment='left',fontsize=8)\n",
    "    plt.plot(CropPatterns.index,CropPatterns.mineral,color='blue')\n",
    "    plt.text(CropPatterns.index[1],CropPatterns.iloc[0,4]*1.1,'Initial N \\n' + str(int(InitialN))+ 'kg/ha',\n",
    "             fontsize=8,horizontalalignment='left',verticalalignment='bottom',color='blue')\n",
    "    plt.plot([CropPatterns.index[1],CropPatterns.index[30]], [CropPatterns.iloc[0,4]]*2,'--',color='blue')\n",
    "    plt.text(CropPatterns.index[-1],CropPatterns.iloc[-1,4]*1.1,'Trigger N \\n' + str(int(FinalN))+ 'kg/ha',\n",
    "             fontsize=8,horizontalalignment='right',verticalalignment='bottom',color='purple')\n",
    "    plt.plot([CropPatterns.index[FirstFertDay],CropPatterns.index[-1]], [CropPatterns.iloc[-1,4]]*2,'--',color='purple')\n",
    "    ax.xaxis.set_major_locator(mdates.MonthLocator(interval=1))\n",
    "    ax.xaxis.set_major_formatter(mdates.DateFormatter('%b'))\n",
    "    plt.xlim(EstabDate,HarvestDate)\n",
    "    plt.ylim(0,maxSoilN*1.5)\n",
    "    return CropPatterns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2001-03-01 00:00:00\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "HarvestedYield = 70 # t/ha fresh weight\n",
    "RejectProportion = 0.1 # Proportion of tubers left in feild\n",
    "TotalProduct = HarvestedYield * (1 + RejectProportion)\n",
    "DryYield = TotalProduct * 1000 * 0.22 # dry matter content of tubers\n",
    "StoverYield = DryYield * 1/0.9 - DryYield # Harvest index\n",
    "RootYield = (StoverYield+DryYield) * 0.1\n",
    "ProductN = DryYield * 0.015\n",
    "StoverN = StoverYield * 0.022\n",
    "RootN = RootYield * 0.01\n",
    "totalN = ProductN + StoverN + RootN\n",
    "ResCoeff = 0.5\n",
    "SOMCoeff = 2.75\n",
    "InitN = 30\n",
    "FinalN = 35\n",
    "Splits = 3\n",
    "GasLosses = 0.1\n",
    "LeachingLosses = 0.0\n",
    "Eff = 1- (GasLosses + LeachingLosses)\n",
    "Fig = plt.figure(figsize=(7,5))\n",
    "ax = Fig.add_subplot(2,2,1)\n",
    "DeriveParamsAndGraph(ax,LincolnMet,'15-Oct','1-Mar','Seed','Maturity',totalN)\n",
    "plt.ylabel('kgN/ha')\n",
    "plt.ylim(0,350)\n",
    "plt.text(0.02,0.98,'Crop N Uptake \\n ' + str(int(totalN)) +' kg/ha',transform=ax.transAxes,verticalalignment='top',color='green')\n",
    "ax = Fig.add_subplot(2,2,2)\n",
    "MinN = MineralisationGraph(ax,LincolnMet,'15-Oct','1-Mar','Seed','Maturity',ResCoeff,'teal')\n",
    "plt.ylabel('kgN/ha')\n",
    "plt.ylim(0,50)\n",
    "plt.text(0.02,0.98,'Crop residue N Mineralisation \\n' + str(int(MinN)) +' kg/ha',\n",
    "         transform=ax.transAxes,verticalalignment='top',color='teal')\n",
    "ax = Fig.add_subplot(2,2,3)\n",
    "SOMN = MineralisationGraph(ax,LincolnMet,'15-Oct','1-Mar','Seed','Maturity',SOMCoeff,'brown')\n",
    "plt.ylabel('kgN/ha')\n",
    "plt.ylim(0,200)\n",
    "plt.text(0.02,0.98,'Soil Organic N Mineralisation\\n' + str(int(SOMN)) +' kg/ha',transform=ax.transAxes,verticalalignment='top',color='brown')\n",
    "ax = Fig.add_subplot(2,2,4)\n",
    "CropPats = Deficit(ax,LincolnMet,'15-Oct','1-Mar','Seed','Maturity',ResCoeff,SOMCoeff,InitN,FinalN,totalN,Splits,Eff)\n",
    "plt.ylabel('kgN/ha')\n",
    "plt.text(0.02,0.92,'Soil Mineral N',transform=ax.transAxes,color='blue')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,py:light"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}