{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d83317f1-25cc-4336-9396-b08cf81629a8",
   "metadata": {},
   "source": [
    "# Create ALM NREL 5MW case\n",
    "This one uses OpenFAST v4.0.2 model of the NREL5MW using ROSCO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5a4532ec-beb7-40a1-9e69-8f9a115aba66",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/ascldap/users/lcheung/.local/lib/python3.9/site-packages/pandas/core/computation/expressions.py:21: UserWarning: Pandas requires version '2.8.4' or newer of 'numexpr' (version '2.8.1' currently installed).\n",
      "  from pandas.core.computation.check import NUMEXPR_INSTALLED\n",
      "/ascldap/users/lcheung/.local/lib/python3.9/site-packages/pandas/core/arrays/masked.py:60: UserWarning: Pandas requires version '1.3.6' or newer of 'bottleneck' (version '1.3.4' currently installed).\n",
      "  from pandas.core import (\n"
     ]
    }
   ],
   "source": [
    "# Add any possible locations of amr-wind-frontend here\n",
    "amrwindfedirs = ['/projects/wind_uq/lcheung/amrwind-frontend',\n",
    "                 '/projects/wind_uq/lcheung/amrwind-frontend/utilities',\n",
    "                ]\n",
    "import sys, os, shutil\n",
    "for x in amrwindfedirs: sys.path.insert(1, x)\n",
    "\n",
    "# Load the libraries\n",
    "import amrwind_frontend  as amrwind\n",
    "import downloadOFmodel\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy             as np\n",
    "import math\n",
    "import pandas as pd\n",
    "import postproamrwindsample as ppsample\n",
    "import time\n",
    "import utm\n",
    "import shutil\n",
    "import yaml\n",
    "\n",
    "# Also ignore warnings\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# Make all plots inline \n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dfa69e4a-16f4-4657-8dc0-50797ddf44b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start the AMR-Wind case\n",
    "case = amrwind.MyApp.init_nogui()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b85cf0d9-b8eb-4d20-a2e2-5eb73f0e17e7",
   "metadata": {},
   "source": [
    "## Load the turbine model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c3cf1294-6310-435e-9c96-8978f8c18b82",
   "metadata": {},
   "outputs": [],
   "source": [
    "downloadrecipe    = 'nrel5mw_v402_rosco.yaml'\n",
    "downloadturbmodel = True                       # if True, download the turbine model from github\n",
    "turbdeffile       = 'NREL5MW_v402_ROSCO.yaml'\n",
    "addturbdef        = True                       # if True, add turbine model type to amr-wind-frontend turbine models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "012b069f-d79c-41e4-9324-fb9125b5ceca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EXECUTING git clone -b v4.0.2 -n --depth=1 --filter=tree:0 git@github.com:OpenFAST/r-test.git\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Cloning into 'r-test'...\n",
      "Warning: No xauth data; using fake authentication data for X11 forwarding.\n",
      "X11 forwarding request failed on channel 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EXECUTING git sparse-checkout set --no-cone glue-codes/openfast/5MW_Baseline glue-codes/openfast-cpp/5MW_Land_DLL_WTurb_cpp\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning: No xauth data; using fake authentication data for X11 forwarding.\n",
      "X11 forwarding request failed on channel 0\n",
      "Warning: No xauth data; using fake authentication data for X11 forwarding.\n",
      "X11 forwarding request failed on channel 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GITHASH = df9ee7d\n",
      "Downloading https://raw.githubusercontent.com/NREL/ROSCO/cfda6af95cda15616b840199c24fbd208e63893c/Examples/Test_Cases/NREL-5MW/DISCON.IN\n",
      "Downloading https://raw.githubusercontent.com/NREL/ROSCO/cfda6af95cda15616b840199c24fbd208e63893c/Examples/Test_Cases/NREL-5MW/Cp_Ct_Cq.NREL5MW.txt\n",
      "Editing NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/5MW_Land_DLL_WTurb_cpp.fst\n",
      "['EDFile', 'ServoFile', 'AeroFile', 'BDBldFile(1)', 'BDBldFile(1)_BldFile']\n",
      "Editing /projects/wind_uq/lcheung/exawind-benchmarks.redoALM/amr-wind/actuator_line/NREL5MW_ALM_BD/setup/NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/NRELOffshrBsline5MW_Onshore_ElastoDyn.dat\n",
      "Editing /projects/wind_uq/lcheung/exawind-benchmarks.redoALM/amr-wind/actuator_line/NREL5MW_ALM_BD/setup/NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/NRELOffshrBsline5MW_Onshore_ServoDyn.dat\n",
      "Editing /projects/wind_uq/lcheung/exawind-benchmarks.redoALM/amr-wind/actuator_line/NREL5MW_ALM_BD/setup/NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/NRELOffshrBsline5MW_Onshore_AeroDyn.dat\n",
      "Editing /projects/wind_uq/lcheung/exawind-benchmarks.redoALM/amr-wind/actuator_line/NREL5MW_ALM_BD/setup/NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/../../openfast/5MW_Baseline/NRELOffshrBsline5MW_BeamDyn.dat\n",
      "GRABFROMFILE: /projects/wind_uq/lcheung/exawind-benchmarks.redoALM/amr-wind/actuator_line/NREL5MW_ALM_BD/setup/NREL5MW_v402_ROSCO/openfast/5MW_Baseline/NRELOffshrBsline5MW_BeamDyn_Blade.dat\n",
      "Editing /projects/wind_uq/lcheung/exawind-benchmarks.redoALM/amr-wind/actuator_line/NREL5MW_ALM_BD/setup/NREL5MW_v402_ROSCO/openfast/5MW_Baseline/NRELOffshrBsline5MW_BeamDyn_Blade.dat\n",
      "NREL5MW_v402_ROSCO.yaml\n",
      "Saved turbine setup to NREL5MW_v402_ROSCO.yaml\n",
      "turbinetype_name = 'NREL5MW_v402_ROSCO_ALM_BD'\n",
      "turbinetype_comment = None\n",
      "Actuator_type = 'TurbineFastLine'\n",
      "Actuator_openfast_input_file = 'NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/5MW_Land_DLL_WTurb_cpp.fst'\n",
      "Actuator_rotor_diameter = 126\n",
      "Actuator_hub_height = 90\n",
      "Actuator_num_points_blade = 25\n",
      "Actuator_num_points_tower = 11\n",
      "Actuator_epsilon = [2.0, 2.0, 2.0]\n",
      "Actuator_epsilon_tower = [2.0, 2.0, 2.0]\n",
      "Actuator_openfast_start_time = 0.0\n",
      "Actuator_openfast_stop_time = 2000.0\n",
      "Actuator_nacelle_drag_coeff = 0.0\n",
      "Actuator_nacelle_area = 0.0\n",
      "Actuator_output_frequency = 10\n",
      "turbinetype_filedir = 'NREL5MW_v402_ROSCO'\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0.0008608815426997245 DT - Recommended module time step (s) [EDITED]\n",
      "         2 CompElast - Compute structural dynamics (switch) {1=ElastoDyn 2=ElastoDyn + BeamDyn for blades 3=Simplified ElastoDyn} [EDITED]\n",
      "         2 CompInflow - Compute inflow wind velocities (switch) {0=still air 1=InflowWind 2=external from ExtInflow} [EDITED]\n",
      "       1.0 AirDens - Air density (kg/m^3) [EDITED]\n",
      "0.0215220385675 DT_Out - Time step for tabular output (s) (or \"default\") [EDITED]\n",
      "         3 OutFileFmt - Format for tabular (time-marching) output file (switch) {1: text file [<RootName>.out] 2: binary file [<RootName>.outb] 3: both 1 and 2 4: uncompressed binary [<RootName>.outb 5: both 1 and 4} [EDITED]\n",
      "     False YawDOF - Yaw DOF (flag) [EDITED]\n",
      "      30.0 NacYaw - Initial or fixed nacelle-yaw angle (degrees) [EDITED]\n",
      "/projects/wind_uq/lcheung/amrwind-frontend/turbines/OpenFAST_NREL2p8-127_AWAKEN/libdiscon.so DLL_FileName - Name/location of the dynamic library {.dll [Windows] or .so [Linux]} in the Bladed-DLL format (-) [used only with Bladed Interface] [EDITED]\n",
      "         1 Ptch_Cntrl - Record 28: Use individual pitch control {0: collective pitch 1: individual pitch control} (switch) [used only with Bladed Interface] [EDITED]\n",
      "         0 Wake_Mod - Wake/induction model (switch) {0=none 1=BEMT 3=OLAF} [Wake_Mod cannot be 2 or 3 when linearizing] [EDITED]\n",
      "         0 UA_Mod - Unsteady Aero Model Switch (switch) {0=Quasi-steady (no UA) 2=B-L Gonzalez 3=B-L Minnema/Pierce 4=B-L HGM 4-states 5=B-L HGM+vortex 5 states 6=Oye 7=Boeing-Vertol} [EDITED]\n",
      "        48 kp_total - Total number of key points (-) [must be at least 3] [EDITED]\n",
      "        48 station_total - Number of blade input stations (-) [EDITED]\n",
      "1.0 ! WE_RhoAir\t\t\t- Air density, [kg m^-3] [EDITED]\n"
     ]
    }
   ],
   "source": [
    "curdir=os.getcwd()\n",
    "\n",
    "if downloadturbmodel:\n",
    "    # Load the turbine type from the download recipe file\n",
    "    with open(downloadrecipe) as f:\n",
    "        yamldict = yaml.safe_load(f)\n",
    "        downloadOFmodel.processModelDict(yamldict)\n",
    "        \n",
    "if addturbdef:\n",
    "    # Load the turbine type from the download recipe file\n",
    "    with open(turbdeffile) as f:\n",
    "        yamldict = yaml.safe_load(f)\n",
    "    \n",
    "        #copy stuff over from the YAML definition\n",
    "        turbinetype = case.get_default_turbinetypedict()\n",
    "        for k, g in yamldict['turbines']['nre5mwFSIROSCO'].items():\n",
    "            turbinetype[k] = g\n",
    "            print(k+' = '+repr(g))\n",
    "        \n",
    "        turbinetype['turbinetype_filelocation']  = curdir\n",
    "    \n",
    "        # Add it to the list of turbine types\n",
    "        case.add_populatefromdict('listboxturbinetype', turbinetype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fab1196-8673-49fa-807b-16f6eb52c7c4",
   "metadata": {},
   "source": [
    "## Load the precursor data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bd3e79a-a407-49eb-97ab-c886cec4c75f",
   "metadata": {},
   "source": [
    "**Note**: in order to run this notebook correctly, you need access to the precursor run directory, and the setup/postprocessing files in there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7b272107-c448-4a70-a5c1-88bc53c15ae7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CANNOT update: ABLMeanBoussinesq use forcechange=True in setval()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "OrderedDict([('io.KE_int', '-1'),\n",
       "             ('io.line_plot_int', '1'),\n",
       "             ('CoriolisForcing.turn_off_vertical_force', 'True')])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Location of precursor run with boundary data\n",
    "precursordir  = '/tscratch/lcheung/HFM/exawind-benchmarks/convective_abl'\n",
    "precursorsetup= precursordir+'/neutral_abl_bndry.inp'\n",
    "\n",
    "# Location of farm run dir\n",
    "farmrundir       = '../input_files'              # Put all AMR-Wind input files here \n",
    "outputfile       = 'NREL5MW_ALM_BD_OFv402.inp'   # Input file for AMR-Wind run with OpenFAST ALM turbine \n",
    "noturboutputfile = 'NREL5MW_ALM_BD_noturb.inp'   # Input file for AMR-Wind run with no turbine present\n",
    "BRoutputfile     = 'NREL5MW_BR.inp'              # AMR-Wind input file for the blade-resolved run with ExaWind hybrid solver\n",
    "\n",
    "verbose          = True\n",
    "cwd              = os.getcwd()\n",
    "\n",
    "# Go to the run directory\n",
    "#if os.path.exists(farmrundir):\n",
    "#    shutil.rmtree(farmrundir)\n",
    "\n",
    "os.makedirs(farmrundir, exist_ok = True)\n",
    "os.chdir(farmrundir)\n",
    "\n",
    "# Load the starting point\n",
    "case.loadAMRWindInput(precursorsetup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5a7675d0-1b74-4667-bf69-89e7758e02f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "tstart = 15000\n",
    "tstop  = tstart+1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ed03ae78-e1ae-467c-9bd5-77fb101aecd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "OFdt = 0.0008608815426997245      # Time step for OpenFAST beamdyn\n",
    "\n",
    "# Set the time constants\n",
    "case.setAMRWindInput('time.stop_time', tstop)\n",
    "case.setAMRWindInput('time.fixed_dt', OFdt*20)\n",
    "case.setAMRWindInput('time.max_step',  -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "66c6b64c-62df-46e7-8f36-f9d78f7f445d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set verbosity\n",
    "case.setAMRWindInput('incflo.verbose', 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6f70bf95-f89a-4705-9680-22cdf6c20e13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the restart point\n",
    "chkdir = precursordir+'/chk30000/'\n",
    "case.setAMRWindInput('restart_file', os.path.realpath(chkdir))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7877c05f-3c1d-405b-956b-5fb53fc492b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the boundary input file parameters\n",
    "ablstatfile = precursordir+'/post_processing/abl_statistics30000.nc'\n",
    "#tavg        =  [tstart, tstop]\n",
    "tavg        = [15000, 16000]\n",
    "forcingdict = {'ablstatfile':ablstatfile, 'tavg':tavg}\n",
    "inflowplanes= ['xlo', 'ylo'] \n",
    "bndryfiles  = precursordir+'/bndry_file'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b37ae82b-80dc-4b21-9562-1b9d13a82e8c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SET ABL_bndry_io_mode = '1'\n",
      "SET ABL_bndry_file = '/tscratch/lcheung/HFM/exawind-benchmarks/convective_abl/bndry_file'\n",
      "SET ABL_bndry_planes = ['xlo', 'ylo']\n",
      "SET is_periodicx = False\n",
      "SET is_periodicy = False\n",
      "SET xlo_type = 'mass_inflow'\n",
      "SET xlo_density = 1.0\n",
      "SET xlo_temperature = 0.0\n",
      "SET xlo_tke = 0.0\n",
      "SET ylo_type = 'mass_inflow'\n",
      "SET ylo_density = 1.0\n",
      "SET ylo_temperature = 0.0\n",
      "SET ylo_tke = 0.0\n",
      "SET xhi_type = 'pressure_outflow'\n",
      "SET xhi_density = None\n",
      "SET xhi_temperature = None\n",
      "SET xhi_tke = None\n",
      "SET yhi_type = 'pressure_outflow'\n",
      "SET yhi_density = None\n",
      "SET yhi_temperature = None\n",
      "SET yhi_tke = None\n",
      "SET BodyForce = True\n",
      "SET BodyForce_magnitude = [-0.0002743665569299508, 0.0011708563286373845, 0.0]\n",
      "SET ABLForcing = False\n",
      "SET ABLMeanBoussinesq = True\n",
      "Loading theta\n",
      "SET read_temperature_profile = True\n",
      "SET temperature_profile_filename = 'avg_theta.dat'\n",
      "Loading u\n",
      "Loading v\n",
      "Loading theta\n",
      "Loading hvelmag\n",
      "SET wf_velocity = [6.0977889026612075, 3.6097639593035185]\n",
      "SET wf_vmag = 7.103916682319445\n",
      "SET wf_theta = 300.20261481689676\n",
      "SET wall_shear_stress_type = 'local'\n",
      "SET checkpoint_start = 30000\n"
     ]
    }
   ],
   "source": [
    "case.boundaryplane_restart(bndryfiles=bndryfiles, \n",
    "                           forcingdict=forcingdict, \n",
    "                           inflowplanes=inflowplanes, \n",
    "                           checkpointdir=chkdir,\n",
    "                           autoset_wf_properties=True,\n",
    "                           ABLMeanBoussinesqTemperatureFile='avg_theta.dat',\n",
    "                           verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca419ae2-bf28-45e5-8848-79597d4b7d90",
   "metadata": {},
   "source": [
    "## Add the turbine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e1847fc8-5b7f-4a9a-9dd5-c2076ef69bf3",
   "metadata": {},
   "outputs": [],
   "source": [
    "turbbase_xy = [[1800, 1800]]\n",
    "eps         = 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4574e471-bc21-4807-8eb9-92229dcd99ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "# CSV file should have columns with\n",
      "# name, x, y, type, yaw, hubheight, options\n",
      "T0, 1800.000000, 1800.000000, NREL5MW_v402_ROSCO_ALM_BD, 240.0, ,FSTparam_DT:0.0008608815426997245 EDparam_YawDOF:False AMRparam_Actuator_epsilon:[2.0;2.0;2.0] AMRparam_Actuator_epsilon_tower:[2.0;2.0;2.0] AMRparam_Actuator_openfast_stop_time:3000.0 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Build the CSV input file of turbine layouts for amrwind-frontend\n",
    "OFoptions=(\n",
    "           # \"FSTparam_CompServo:0 \"\n",
    "           \"FSTparam_DT:0.0008608815426997245 \"\n",
    "           \"EDparam_YawDOF:False \"\n",
    "           \"AMRparam_Actuator_epsilon:[{eps};{eps};{eps}] \"\n",
    "           \"AMRparam_Actuator_epsilon_tower:[{eps};{eps};{eps}] \"\n",
    "           \"AMRparam_Actuator_openfast_stop_time:3000.0 \"\n",
    "          ).format(eps=eps)\n",
    "#\"ADparam_TwrAero:False ADparam_TwrShadow:0 ADparam_TwrPotent:0 \"\n",
    "\n",
    "turbinescsv=\"\"\"\n",
    "# CSV file should have columns with\n",
    "# name, x, y, type, yaw, hubheight, options\n",
    "\"\"\"\n",
    "rowformat=\"T%i, %f, %f, NREL5MW_v402_ROSCO_ALM_BD, 240.0, ,%s\\n\"\n",
    "for iturb, xy in enumerate(turbbase_xy):\n",
    "    turboptions  = OFoptions\n",
    "    turbinescsv += rowformat%(iturb, xy[0], xy[1], turboptions)\n",
    "case.setAMRWindInput('turbines_csvtextbox',  turbinescsv)\n",
    "print(turbinescsv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6d6a4f69-82fb-422d-9d8a-9afe84a1d03a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "docopy = True from /projects/wind_uq/lcheung/exawind-benchmarks.redoALM/amr-wind/actuator_line/NREL5MW_ALM_BD/setup/NREL5MW_v402_ROSCO to T0_NREL5MW_v402_ROSCO\n",
      "T0_NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/5MW_Land_DLL_WTurb_cpp.fst\n",
      "Setting Actuator_epsilon to [2.0, 2.0, 2.0]\n",
      "Setting Actuator_epsilon_tower to [2.0, 2.0, 2.0]\n",
      "Setting Actuator_openfast_stop_time to 3000.0\n",
      "OrderedDict([('DT', 0.0008608815426997245)])\n",
      "OrderedDict([('YawDOF', 'False')])\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0.0008608815426997245 DT - Recommended module time step (s) [EDITED] [EDITED]\n",
      "     False YawDOF - Yaw DOF (flag) [EDITED] [EDITED]\n"
     ]
    }
   ],
   "source": [
    "case.setAMRWindInput('turbines_createnewdomain', False)\n",
    "case.setAMRWindInput('turbines_deleteprev', True)\n",
    "\n",
    "case.turbines_createAllTurbines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f514f407-f0fa-4d04-9374-1a0ba1b5c4e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 750x750 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(6,6), facecolor='w', dpi=125)\n",
    "\n",
    "# Set any additional items to plot\n",
    "case.popup_storteddata['plotdomain']['plot_turbines']        = case.listboxpopupwindict['listboxactuator'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_refineboxes']     = case.listboxpopupwindict['listboxtagging'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes']    = [] #['p_hub']\n",
    "case.plotDomain(ax=ax)\n",
    "for iturb, xy in enumerate(turbbase_xy):\n",
    "    ax.plot(xy[0], xy[1], 'ks')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cff2cca4-eb04-4bcd-8dcb-58474513d616",
   "metadata": {},
   "source": [
    "## Add refinement regions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ed358134-dd34-4ef1-afe8-15bf579fc579",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Add refinement zones\n",
    "refinementcsv=\"\"\"\n",
    "# CSV file should have columns with\n",
    "# level, upstream, downstream, lateral, below, above, options\n",
    "level, upstream, downstream, lateral, below, above, options\n",
    "0,     5,        10,         5,     0.75,   2,\n",
    "1,     2.5,      5,          2,     0.75,   1.5,\n",
    "2,     1.25,     2.0,        1.25,  0.75,   1.0, \n",
    "3,     0.75,     0.75,       1.00,  0.75,   0.75, \n",
    "\"\"\"\n",
    "case.setAMRWindInput('refine_csvtextbox', refinementcsv)\n",
    "case.setAMRWindInput('refine_deleteprev', True)\n",
    "\n",
    "# Uncomment this to create refinement zones\n",
    "case.refine_createAllZones()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a3acf68c-e640-434e-8489-8f21144a2f11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqAAAAKgCAYAAABEPM/FAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAABM5AAATOQGPwlYBAACB2klEQVR4nOzdd3QVdd7H8fckN70TEkgoIQqIVCFgAQERRUSqihFEmqywxYhl5VFYF1RcRFxRYRFFiiKguIqKiFKsqCtFEBUp0kkgAdJ77p3nDx/zmE0gCUlmbpLP65x7Dpn5zW++987h5pMpv59hmqaJiIiIiIhFPOwuQERERETqFwVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVESkigzDKPHy8vKiYcOGdOjQgbFjx/Lvf/+boqIiu8usVp9++imGYTB27Fi7SxGRWshhdwEiInXFmDFjAHC5XKSnp7Nv3z5effVVli1bRsuWLXn99de5/PLLba5SRMR+hmmapt1FiIjUZoZhAFDW1+kvv/zCI488wptvvom/vz9btmzhsssus7jC6peTk8PRo0cJCQkhKirK7nJEpJZRABURqaLzBdDfTJgwgVdeeYXOnTuzY8cOq0oTEXFLugdURMQCzzzzDAEBAXz33Xd8+eWXpdZ//fXXDBkyhIiICHx8fGjRogV/+tOfSExMLNV26dKlGIbB9OnT+eWXX7jtttto2LAhwcHB3Hjjjfz0008AFBUV8eSTT9K6dWt8fX1p2bIl//rXv8qs74MPPmD8+PFceumlBAcHExAQQKdOnXjyySfJz88v1f5c94BOnz4dwzBYunQpu3fvZvDgwYSFhREQEEDv3r356quvLuDTE5G6RgFURMQCISEh3HjjjQB88sknJdYtX76cnj178v7773PJJZdw88034+Pjw4IFC+jSpQs///xzmX0eOnSIyy+/nO3bt9O7d29atGjB+vXrueaaazh58iS33nors2bNIjY2lmuuuYZjx47x5z//mZdffrlUX3fddRerV68mJCSE/v3707NnT44dO8bUqVMZMGAATqezUu9327ZtXHnllezdu5e+ffvSqlUrPv/8c/r27csPP/xQqb5EpA4yRUSkSgCzIl+nTzzxhAmYI0aMKF529OhR08/Pz3Q4HOb7779fvNzpdJqTJ082AbNbt24l+lmyZEnxPu+//37T6XSapmmaLpfLHDt2rAmYbdu2Ndu3b28eO3aseLuNGzeagBkTE1OqtnfeecfMysoqsSwjI8McOHCgCZjLli0rse6TTz4xAXPMmDEllv/9738vru2pp54qse6393PnnXeW+1mJSN2mM6AiIhZp2LAhAKmpqcXLFi1aRG5uLiNGjGDgwIHFyz08PJg1axbR0dFs3bqVb775plR/F198MU899RQeHr9+lRuGwf333w/ATz/9xPPPP0/Tpk2L2/ft25fOnTtz5MgRDh8+XKKvoUOHEhAQUGJZUFAQzz77LADvvvtupd7r1VdfzUMPPVRi2bRp0wD4/PPPK9WXiNQ9GoZJRMQi5v89pPTbQ0sAX3zxBQB33HFHqfY+Pj4MHz6c5557ji+++IIrr7yyxPprrrkGh6Pk1/hFF10EgLe3N7179y7V58UXX8x3331HUlISLVq0KLFu//79rFu3jgMHDpCdnY3L5Squef/+/ZV6r/369Su1LDw8nPDwcJKSkirVl4jUPQqgIiIWOX36NAANGjQoXvbbQ0b/HQZ/89vysh5GatKkSallv53FbNy4cfGZ0bLW//7BItM0efDBB3n22WfP+SR/ZmZmmcvP5fdnXn8vMDCQM2fOVKovEal7dAleRMQiO3fuBKBt27al1v3+rGhZylp/vm3K6+/33njjDf75z3/SpEkT3nrrLU6cOEFBQQGmaRYH1XMF0+rYv4jUPwqgIiIWSE9PZ/369QD06dOneHl0dDTw6xPtZTly5AhAjQ72/s477wCwYMECbrnlFqKjo/Hy8gLg4MGDNbZfEam/FEBFRCzwwAMPkJ2dTbdu3bjqqquKl/fs2ROA119/vdQ2BQUFrF69ukS7mvDbQ1HNmjUrte7NN9+ssf2KSP2lACoiUoMOHjxIfHw8r7zyCgEBAbzyyisl1t911134+fmxcuVKPvjgg+LlLpeLRx55hBMnTtCtW7dSDyBVp9atWwPw0ksvlbjU/sUXX/D000/X2H5FpP7SQ0giItXkt1mBXC4XGRkZ7Nu3j59//hnTNGnVqhUrVqygQ4cOJbZp3rw5L730EmPHjmXQoEH06NGDZs2asWPHDvbu3UujRo149dVXa7TuhIQEli5dyr/+9S8+/fRTOnbsyIkTJ/jyyy954IEHmDNnTo3uX0TqH50BFRGpJsuWLWPZsmWsXLmSL774Ak9PT0aPHs2///1vfvrpJ7p27VrmdqNGjeLzzz9n4MCB7Nmzh7feeovc3Fz++Mc/sn37dtq0aVOjdbdu3ZqtW7cyaNAgTp8+zXvvvUdWVhYLFy7UGVARqRGGWdlHG0VEREREqkBnQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKU0FacNTp8+zUcffUSLFi3w8/OzuxwRERGRC5abm8vhw4e54YYbaNiwYYW2UQC1wUcffcSoUaPsLkNERESk2ixfvpw77rijQm0VQG3QokUL4NcDdemll9pbjIiIiEgV7Nmzh1GjRhXnm4pQALXBb5fdL730Urp06WJzNSIiIiJVV5nbCvUQkoiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqNQOd98NGzbYXYWIiIhUA4fdBYiUKzMTli6FEyfg+uvtrkZERESqSGdAxf29+y54e8OWLZCXZ3c1IiIiUkUKoOL+Xn4ZsrPBNGH9erurERERkSpSABX3lpkJu3b9+u+MjF/DqIiIiNRqCqDi3t59F4qK/v9nXYYXERGp9fQQUh118uRJin4f3GqpiHnz8MnOLv7Z5XRy9vXXybvhBhurEhERqR0cDgeNGze2u4xSFEDrqKKiIo4fP46np6fdpVwwj+xsGv/4Y8llWVk4Fi8mqWNHm6oSERGpHZxOJ02bNrW7jDIpgNZhnp6eRERE2F3GBQvYsgUPl6vU8qDdu4kMDsb08bGhKhERkdohJSXF7hLOSfeAitsKWrkSj5ycUssN08T3889tqEhERESqgwKouCUjKwvvH34oc51HVhZBK1ZYXJGIiIhUF12CF7dkFBRQ2LIlRn4+AN579wJQcMklABQ1a2ZbbSIiIlI1CqDillwNGpD07rvFP7eIjSX1vvtIT0iwsSoRERGpDroELyIiIiKWcusAevjwYQzDKPM1YcKEEm2dTiezZs2iZcuW+Pj40LJlS2bNmoXT6SzVb021FREREZHy1YpL8EOGDOHWW28tsaxly5Ylfr7nnntYsGAB48aNo3v37nz11Vc8/PDDHDt2jPnz51vSVkRERETKVysCaPv27Rk1atQ51+/evZsXX3yRhIQEnnvuOQAmTJhAUFAQL7zwApMmTaJDhw412lZEREREKsatL8H/Xm5uLrm5uWWuW7VqFaZpMnny5BLLJ0+ejGmarFq1qsbbioiIiEjF1IoA+txzz+Hv74+/vz+tWrUqdel727ZtNGrUiNjY2BLLY2NjiYyMZPv27TXe9lySkpLYsWNHideePXsq/N5FRERE6hq3vgTv4eFB3759GTp0KDExMSQmJrJo0SL+8pe/cPjwYZ5++mkAEhMTadKkSZl9NGnShBMnThT/XFNtz2XhwoXMmDGj3HYiIiIi9YVbB9DmzZuzcePGEssmTJjAtddeyz//+U8mTZrExRdfTE5ODkFBQWX24evrS0ZGRvHPNdX2XCZOnMjgwYNLLNuzZ89572kVERERqcvcOoCWxdPTkwcffJDPP/+cTZs2cfHFF+Pv70/+/82Y89/y8vLw8/Mr/rmm2p5LVFQUUVFR5bYTERERqS9qxT2g/y0mJgaA06dPAxAdHX3Oy+EnTpwocRm9ptqKiIiISMXUygB64MABABo1agRAXFwcp06d4tChQyXaHTp0iOTkZOLi4oqX1VRbEREREakYtw6gZ8+eLbUsNzeXJ554Ai8vL/r16wdAfHw8hmEwd+7cEm3nzp2LYRjEx8cXL6uptiIiIiJSMW59D+iECRPIycnhyiuvpGnTpiQmJrJs2TIOHjzIP/7xD5o1awZAp06duPvuu3n++efJzMykR48ebNmyhSVLljBx4kQ6duxY3GdNtRURERGRinHrAHrTTTexbNkyFixYwNmzZwkMDKRLly48++yzpZ4snzdvHs2bN2fRokUsX76cpk2bMnPmTB566KFS/dZUWxEREREpn2Gapml3EfXNjh07iIuLY/v27XTp0qVG9nH8+HGSkpKIiIiokf6t1iI2ltT77iM9IcHuUkRERGqFlJQUoqKiaNq0aY3u50JyjVvfAyoiIiIidY8CqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgUnsYht0ViIiISDVw2F2ASEUkrV5NYevWdpchIiIi1UABVGqF/K5d7S5BREREqokuwYuIiIiIpRRARURERMRSCqAiIiIiYikFUBERERGxlAKo2Mr3m29oERtLi9hY/D79tNT6wLfeokVsLL5ffml9cSIiIlIjFEDFbYT+8592lyAiIiIWUAAVt5Dfvj0+u3fj/9FHdpciIiIiNUwBVNxC1m23URQdTeizz4Jp2l2OiIiI1CAFUHELppcXaffcg/fevQSsXWt3OSIiIlKDFEDFbWTdeiuFLVoQOncuOJ12lyMiIiI1RAFU3IfDQVpCAl4HDxKwZo3d1YiIiEgNUQAVt5I9ZAgFrVoR+vzzUFhodzkiIiJSAxRAxb14eJB27714HT1K4OrVdlcjIiIiNUABVNxOzoABFFx6KaHz5kFBgd3liIiISDVTABX3Yxik3ncfjqQkglautLsaERERqWYKoOKWcq+/nvxOnfD54Qe7SxEREZFqpgAqbiv1/vvtLkFERERqgMPuAqR+y7vySg4fOlT2ul69zrlOREREai+dARURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilalUA3bx5M4ZhYBgGBw4cKLHO6XQya9YsWrZsiY+PDy1btmTWrFk4nc5S/dRUWxEREREpX62ZC76goIA///nPBAQEkJ2dXWr9Pffcw4IFCxg3bhzdu3fnq6++4uGHH+bYsWPMnz/fkrYiIiIiUr5aE0CfeeYZzp49yx/+8Afmzp1bYt3u3bt58cUXSUhI4LnnngNgwoQJBAUF8cILLzBp0iQ6dOhQo21FREREpGJqxSX4I0eO8MQTTzBr1ixCQkJKrV+1ahWmaTJ58uQSyydPnoxpmqxatarG24qIiIhIxdSKM6AJCQl07NiRsWPHMmPGjFLrt23bRqNGjYiNjS2xPDY2lsjISLZv317jbc8lKSmJpKSkEsv27NlT7nYiIiIidZXbB9C1a9eydu1avv32WwzDKLNNYmIiTZo0KXNdkyZNOHHiRI23PZeFCxeWGZpFRERE6iu3DqC5ubkkJCQwYcIE4uLiztkuJyeHoKCgMtf5+vqSkZFR423PZeLEiQwePLjEsj179jBq1KhytxURERGpi9w6gM6cOZO0tDRmzpx53nb+/v7k5+eXuS4vLw8/P78ab3suUVFRREVFldtOREREpL5w24eQEhMTmTNnDnfffTdpaWkcOHCAAwcOcPbsWQCOHj3KwYMHAYiOjj7n5fATJ06UuIxeU21FREREpGLcNoAmJyeTn5/PU089RatWrYpfL7zwAgB9+/alY8eOAMTFxXHq1CkOHTpUoo9Dhw6RnJxc4vJ9TbUVERERkYpx2wAaGxvL6tWrS72GDx8OwAsvvMDy5csBiI+PxzCMUuODzp07F8MwiI+PL15WU21FREREpGLc9h7QkJAQbr311lLLf/jhBwD69+9Py5YtAejUqRN33303zz//PJmZmfTo0YMtW7awZMkSJk6cWHymtCbbioiIiEjFuG0Arax58+bRvHlzFi1axPLly2natCkzZ87koYcesqytiIiIiJTPME3TtLuI+mbHjh3ExcWxfft2unTpUiP7OH78OElJSURERNRI/yIiIuLeUlJSiIqKomnTpjW6nwvJNW57D6iIiIiI1E0KoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERS7l1AN2zZw+33347rVq1IjAwkODgYC677DLmzp1Lfn5+ibZOp5NZs2bRsmVLfHx8aNmyJbNmzcLpdJbqt6baioiIiEj5HHYXcD7Hjh3j7Nmz3H777TRt2hSn08mWLVu4//772bRpE++//35x23vuuYcFCxYwbtw4unfvzldffcXDDz/MsWPHmD9/fol+a6qtiIiIiJTPrQNov3796NevX4llf/rTnwgLC2P+/Pns3buXSy65hN27d/Piiy+SkJDAc889B8CECRMICgrihRdeYNKkSXTo0AGgxtqKiIiISMW49SX4c2nRogUAaWlpAKxatQrTNJk8eXKJdpMnT8Y0TVatWlW8rKbaiohI7WaaJmfPnrW7DJF6wa3PgP4mJyeHnJwcsrOz+fbbb5k9ezbR0dF07NgRgG3bttGoUSNiY2NLbBcbG0tkZCTbt28vXlZTbc8lKSmJpKSkEsv27NlTsTcuIiI15vTp03z//ffs3r2b77//nu+//56zZ8+ydu1aLr30UrvLE6nTakUAnT17NjNmzCj++YorruCll17Cz88PgMTERJo0aVLmtk2aNOHEiRPFP9dU23NZuHBhidpFRMR66enpxWFz9+7d7Nq1q9TJgd/s379fAVSkhtWKADp69Giuvvpqzpw5w+bNm4v/Sv1NTk4OQUFBZW7r6+tLRkZGjbc9l4kTJzJ48OASy/bs2cOoUaPK3VZERCovKyuLH3744Xdh83uOHj1Soo1nUDh+ra7Eu3FLvBs2J/WzZRSdPcFf/vKXUt/ZIlL9akUAveiii7jooosAiI+P59lnn6Vfv37s2rWLSy+9FH9//1LDMv0mLy+v+EwpUGNtzyUqKoqoqKhy24mI1ISMvCJOZhbSOqL876vaLDk5maeeeorvv/+eX375BdM0i9d5+gfje1EcPo1b4R3VCu/GrXAENgDAdDlJeedJis6e4NZbb+X++++36y2I1Cu1IoD+t5EjR3L//fezfPlyZs6cSXR0NLt27Sqz7YkTJ+jcuXPxzzXVVkTEnRQ5TT7cm8qb35/Bz+HBC0Nj8XHUyudOKyQiIoKjR49y4MABvMKb4dfyCryjWuHTuBWewREYhlFqG9M0ObvhRXIP/IfevXvz5JNPltlORKpfrfw2ys3NBSA1NRWAuLg4Tp06xaFDh0q0O3ToEMnJycTFxRUvq6m2IiLu4rsT2dy/9jBLt6WQU+DiTE4R7/xQt5/uNgyDRx999NcA6ekgtNedBFzSA0dI5DlDZcY3q8na+SHt2rVn/vz5eHl5WVy1SP3l1gE0OTm5zOX/+te/gF8fRoJfL8sbhsHcuXNLtJs7dy6GYRAfH1+8rKbaiojY7UR6ATM3HeeJTcc5kV5QYt27P54lOavQpsqs0aFDB4YPH05h8iGyvt9w3rZZP2wi7fNXadK0KUuWLCYgIMCiKkUE3PwS/MSJEzlz5gzXXHMNzZo1Iy0tjY8++ohNmzZx9dVXc8cddwDQqVMn7r77bp5//nkyMzPp0aMHW7ZsYcmSJUycOLF4uKaabCsiYpfsAidv7jrD+r1pFLnMMtsUOE1e257CA72jLa7OGqZpsnbtWr744gsAsnZ+SGCnG8o8+5l7aAdnP3ye0NAwli1dSkREhNXlitR7bh1Ab7/9dpYuXcorr7xCSkoKPj4+tGnThqeffpp77rkHh+P/y583bx7Nmzdn0aJFLF++nKZNmzJz5kweeuihUv3WVFsRESu5TJON+9NZufM0GXnOctt/dSST/qdyaNfI34LqrLN7925mzJjB9u3bMRzehHS/neArbi0zfBac+oXTa/6Bl5eDV15ZxMUXX2xDxSJimL9/VFAssWPHDuLi4ti+fTtdunSpkX0cP36cpKQk/WUvUkf9eDKHxVuTOZxa9kgd59IizIenB8bgUQcetklJSWHOnDmsXr0a0zTxv+RqwvqMwxHSCNNZSOb2tfhd3A2v8KYAFKWf4uTyBzFz0lmwYEGpqZ5F6pqUlBSioqJo2rRpje7nQnKNW58BFRGRkpKzCnl1ewpfH8m8oO0Pp+azaX8617cOrd7CLJSfn8/SpUt54YUXyM7OxisylgZ978a3eQdM0yTnl62kbV5E4dkT5B3ZReTw6ThzM0le/XecWak89thjCp8iNlMAFRGpBfIKXbz9wxne+ymVQmfVLlyt3Hma7i2CCPD2rKbqrGGaJps2beKJJ57gyJEjePoH0+CGvxDY8XoMD08KTx/j7OZF5B3ajqfDQdOmTTl+cBs5+74i49s1FJ45zp/+9CfuvPNOu9+KSL2nACoi4sZM0+TzQ5ks35HC2ZyiaukzPc/J6u/PMLZrZLX0Z4X9+/fz+OOP88UXX2B4eBLUbSih3W/HwzcQZ14W6V+uIOu7DzBdTnr37s3f/vY3XC4X/W+8kZQ1s8B0MWzYMB588EG734qIoAAqIuK29p/OZfHWZPal5FV73x/+nEa/1qFEB3tXe9/VKS0tjblz5/La8uW4nE78Lu5GWJ+78ApviulykvndOtK/WI4zN4PY2Fj+9re/0adPn+Lt7xw1imXLltGjRw9mzZqlgeZF3IQCqIiImzmbU8TrO1L47GAGNfWUaJHLZOm2ZB65tmYfTrhQRUVFrFy5kmee+Sfp6Wl4NWhKw2sn4HdxVwDyjnzP2U0vUZhymMDAQCZPm8add96Jt3fJQD158mQOHDjAggULSq0TEfsogIqIuIlCp4v3f0rl37vPklfkqvH9bT+ezXcnsuncxL0GYd+yZQuPPfYY+/btw8MngLBr/0BQl5swPB0Upp0k7ZPF5Oz7CsMwGDFiBPfffz8NGzYss6/Q0FBeffVVPDzcet4VkXpHAVRExA3852gmy7ancCrT2tmKlmxLpkNUCxwe9l+aPnLkCE8++SQff/wxGB4EXtaf0J534ukfgqsgl7QtK8jc+g5mUSGXX345jz76KO3atSu3X4VPEfejACoiYqMjqfks2ZrM7pM5tuz/RHoB639OZWDbBrbsHyArK4t//etfLFq0iMLCQnyad6BB3z/gHXkRpun6ddrMz5bhzDpLdJMmTH3kEW688UbdzylSiymAiojYIDPfycqdp9mwL41zzJ5pmTe+P0Ovi4IJ9rX2V4LL5eLtt9/mqdmzOZ2SgiOkEQ37jMe/dXcMwyA/cS9nNy6kIGkfvn5+3Hv//fzhD3/A19fX0jpFpPopgIqIWKjIZfLR3jTe2HWa7IKav8+zInIKXKzceYaJVzaybJ87duxg+vTp7N69Gw9vX0J73klQt6F4ePlQlHmatM+Wkf3jJwAMGTKEKVOmEBUVZVl9IlKzFEBFRCyyMzGbJVuTOZ5eYHcppWzcn0b/S0KJCfOp0f0kJSXx1FNP8e677wIQ0K4Pob3H4AhqiFlUQPrXb5LxzZu4CvLo0KEDf//734mLi6vRmkTEegqgIiI1LCmjgKXbktl2PNvuUs7JZcLircnM6NesRvrPy8vjpZdeYsGLL5KXm4t3VGsa9L0bnyZtME2T7L1bSPtkMUXpp2gYEcH/THmCYcOG6QEikTpKAVREpIbkFDh5a/cZPtiTRpHdN3pWwA8nc/j6SCZXxQRVW5+mabJu3Tqe/Mc/SDxxAs/ABoTfNImAdn0wDA8Kkg9ydtPL5B/djZeXF3/84x/505/+RGBgYLXVICLuRwFURKSauUyTTw5ksGJnCmm5TrvLqZRXt6cQ1zQAb8+qn3n86aefmDFjBt9++y2Gw4vgq24j5MrheHj74cxJJ+2L5WTt+ghMFzfccAMPP/wwMTEx1fAuRMTdKYCKiFSjPadyWLw1mYNn8+0u5YIkZxXy/k+p3NIh/IL7OH36NM888wxvvPEGpmni37o7oX3G4xXaGNNZRMbWd0nfsgJXfjatW7fm0UcfpUePHtX4LkTE3VUqgDZv3vyCd2QYBitXrqR79+4X3IeIiLs6nV3Isu0pfHU40+5Squzt3Wfpc3EIDfwrd46ioKCAV199leeee46srCy8IlrQoO/d+MZ0BCD34HZSN79M4ZnjhISE8sDUxxgxYgQOh86FiNQ3lfpff/z4cdq0aUOjRpUbqqOwsJCvv/6avLy8Sm0nIuLu8otcvPPDWd798SwFTve/z7Mi8opcLN+RQsLVFR/26JNPPuHxxx/n0KFDePoF06DfnwjsdAOGhyeFZ46TunkRuQe34eHpyZgxY5g8eTKhoaE19yZExK1V+s/OadOmMXLkyEptc/r0aSIjIyu7KxERt/bFoQxe25HCmewiu0updp8fzKD/JaG0jvA7b7tffvmFxx9/nM8++wzDw5OgrkMI6TECT99AXHlZpH61iqzt72O6nFx99dU8+uijtGrVyqJ3ISLuqlIB9IorriAiIqLSO/H29uaKK64gJCSk0tuKiLibX87ksXhrMj8n59pdSo0x+XVYpn/c2LzMKS/T09N5/vnnWfbqqziLivCN7UKDa/+AV8NmmC4nmTvXk/7Fazhz0omJiWHatGn07dtX02eKCFDJAPr1119f0E6Cg4MveFsREXeRllvE8h0pfHowA7NuXG0/r/2n8/jsYAbXXPz/Jw+cTidvvPEGc+bMITU1Fa+waBr0/QN+F3XFMAzyjv1A6saXKEg+SEBAAAkPP8yYMWPw8anZAe5FpHbRnd8iIuUocpqs3ZPKW7vPkFvoHtNnWmX5jtNc2TwIXy8Pvv76ax577DF+/vlnPHz8CesznqC4QRieXhSlJ5P6yWJy9n6JYRjcdtttPPjggxd01UxE6j4FUBGR89h6LIul25I5mVlodym2SM0tYvGXB9n95jOsX78eDIPATjcQ2vNOPANCcRXkkf7VG2R8+zZmUQFxcXH8/e9/p0OHDnaXLiJurMoBdPny5SxcuJADBw5w9uxZzP+6LmUYBvn5tXM8PBGpv46m5bNkazLfJ+XYXYptTNMkOzubFd+mc3LLdnyatqPBdXfj3ehiTNMk68dPSP9sKUWZZ4iKiuKRRx7hpptu0n2eIlKuKgXQv/3tbzz55JOEh4cTFxenITVEpNbLyneyaudpPt6fjrMWTJ9ZU/Ly8sjKysLpdGI4vGk04kkcoY1/PamQtI/UjS+Rn/gzPr6+/GXyZO6++278/M7/xLyIyG+qFEAXLlxInz59+OCDD3SDuYjUak6Xycf70nhj1xky82vX9JnVqbCwkMzMTAoLC8Ew8PDxw/DywzPAoCgng7RPFpP9w0YABg0axJQpU2jSpInNVYtIbVOlAJqfn8/w4cMVPkWkVvs+KZslW1M4mlZ/bxdyuVxkZWWSm/vrhCGGlw8e3n4YHp6YpomrIJei04fJ/nEz7dq35++PPkq3bt1srlpEaqsqBdDevXvz448/VlctIiKWSsooYNn2FLYey7K7FNuYpklOTg7Z2dmYponh6cDDxx/D0+vX4FlUgJmfg+ly4h3ejHEz/sXUkdfh6elpd+kiUotVKYA+99xzXHvttbRv357x48drPl8RqRVyCp38+/uzrN2TSlE9vs8zPz+PzMz/u8/TwwMPnwAMhzeGYWA6i3AV5GAWFWIYBgEBAQQEBHDQuzF5TghQ/hSRKqhSYoyNjWX69Oncdddd3HPPPTRu3LjUX8WGYfDLL79UqUgRkepgmiaf/JLB69+dJi237k2fWVFFRUVkZmZSUFDw632e3n4Y3r4Yhgem6cKVl4OrKA9M8PHxISgoqPi7PTPfyZu7zjCum6ZXFpELV6UAOn/+fBISEvD29qZly5Z6Cl5E3NbelFxe+TaZX87k2V2KbVwuF9nZWeTm5mKaYDi8f73cXnyfZx5mQQ6maeJwOAgKCsLb27tUP+v3pnF96xCahuj+fxG5MFUKoE899RTdunXjgw8+IDw8vLpqEhGpNmeyC3ltRwpfHMq0uxTbmJjk5uSSnZ2Ny+XC8PDE0zcAw+H16/qiAlz/d5+nh4cHgYGB+Pn7YVD2eJ5FLpOlW1OYdl1TK9+GiNQhVQqgZ86c4eGHH1b4FBG3k1/k4t0fz7Lmx7PkF9Xf+zwLCvLJzMyiqKgIw/i/+zy9fH69z9Pl/DV4FhVgGODv709AQAAeHh7l9vtdYjbbjmfRtWmgBe9CROqaKgXQbt26cfjw4WoqRUSkemw5nMFr20+Tkl0/p88EKHIWkZWZ9etMdAZ4ePtiePv9/32e+bm4CvPANPH29iYoKKjSD5Iu3ZbCZVEBODw185GIVE6VAuizzz7LwIED6dmzJwMHDqyumkRELsjBs3ks/jaZPcm5dpdiq6KiouKpkQ2HFx7e/hiejl/v8yzMwyzIxXS58PT0JCgo6ILHck7KKGDd3lQGt21Qze9AROq6KgXQe++9F19fX4YMGUJUVBQxMTFlPgX/2WefValIEZHzSc8r4vXvTrP5QDpm/b3aXszhcODl5UVBQQEeXr6/hk9n4a+X251FGIZBYFAg/n7+VZ63ffX3Z+h9UTAhvhqGT0QqrkrfGEePHsUwDJo3bw5AYmJitRQlIlIRRU6TD35O5a3dZ8gpcNldjlsJCgri7NmzuPJzoKgAs/DXWZ78/PwIDAys0H2eFZFT4GLFd6f541WNq6U/EakfqhRAdf+niNhl27Eslm5PISmjwO5S3JLD4cDPz4+cnBxwOfHy9iIoMAgvL69q39emA+n0vySU2Aa+1d63iNRNumYiIrXK8fR8lm5N4bvEbLtLcXsBAQEUFBYQ4B+Ar2/NhUPThMVbk3n8huY1tg8RqVsUQEWkVsgucPLGrjOs35uGsx5Pn1kZHh4ehDewZpi8n07l8tXhTLq3CLJkfyJSu1XqJqDu3buzYcOGSu8kIyOD7t27s3379kpvKyL1m9Nl8tHeNP78ziE+2JOq8OnGXt2eQoFT9+KKSPkqdQb0m2++4fTp05XeSWFhId988w3p6emV3lZE6q/dSTks2ZbMkdR8u0uRCkjJLuTdH84yvFNDu0sRETdX6UvwTzzxBC+//HKltiksLKzyUB8iUn+cyixg2fYU/nM0y+5SpJLe+fEs17YMITyg+h92EpG6o1IBtFevXr9O31bJgfYcDge9evUiLCysUtuJSP2SW+ji7R/O8P5PqRQ6dam9NsovMnltRwqTe0bbXYqIuLFKBdBPP/20hsoQkfrMNE0+O5jB8h2nSc0tsrscqaIvDmVyY5tcLonws7sUEXFT1TMSsYjIBdqXksvDHx7lhS0nFT7rkMXfJlf6apmI1B8ahklEbHE2p4jlO1L4/GAGiil1z4EzeXzySwbXtgyxuxQRcUMKoCJiqQKni/d+TOXtH86SX6Qhe+qy1787zZUxgfh7edpdioi4GQVQEbHM10cyeXV7CslZhXaXIhZIyy3i39+f5c64CLtLERE3owAqIjXuSGo+r2xN5seTOXaXIhZbuyeV61uH0DjI2+5SRMSN6CEkEakxGXlFLPzmJA+uPazwWU8VuUyWbUuxuwwRcTNVCqD33nsvO3furKZSRKSuKHKavP/TWf685hAf70tHs2fWb98ey+L7pGy7yxARN1KlALpgwQLi4uK47LLLeO655y5omk4RqVu+O5HN/WsPs3RbCjkFeshIfrVkawpO/SUiIv+nSgH0+PHjzJ49G9M0ue+++2jSpAk333wz7733Hk6ns7pqFJFaIDGjgJmbjvPEpuOcSC+wuxxxM0fT8vl4X5rdZYiIm6hSAI2MjOSBBx5g165dbNu2jUmTJvHll18ydOhQoqOjeeCBB/j++++rq1YRcUPZBU6WbkvmvvcOs+OELrPKub2x6wxZ+To5ISLV+BBSly5deO6550hMTOSdd94hLi6OuXPn0rlzZ+Li4liwYAG5ubnVtTsRsZnLNPl4Xxp/WXOI939KpUiXV6UcmflOVu3SrVoiUgNPwe/YsYOPP/6Yb775BtM0adOmDU6nkz//+c9cfPHFfPnll9W9SxGx2I+ncvjr2iMs/OYUGXk6oyUV9/G+dI6l5dtdhojYrFoCaGJiIk899RRt27blqquuYvny5dxyyy189dVX/Pjjj+zcuZMvvviCkJAQ/vSnP1XHLkXEBslZhTzzWSKPfnSMw6kKEVJ5TpfJkm3JdpchIjar0kD0K1euZNmyZWzatAmn00nPnj2ZMmUKw4cPx9/fv0TbHj168Ne//pWJEydWqWARsV5+kYu3d5/l3Z/OUujUpXapml2JOWw9lkW3ZoF2lyIiNqlSAL3jjjuIjo7mr3/9K+PHj6dly5bnbd++fXtGjRpVlV2KiMU+P5jB8h0pnMkpsruUWuEa81u6mj8yx2Oc3aW4taXbkukcHYDD07C7FBGxQZUC6Nq1a+nfvz8eHhW7kn/55Zdz+eWXV2WXImKR/adzWbw1mX0peXaXUiu0NI/wR/MN2vELAF+Zl/GV0dnmqtzXycxC1u5JZWj7BnaXIiI2qFIAHTBgQHXVISJuIjW3iOU7Uvjslwx0sb18oWYG4823uZ6v+f25vD+Yb/EtHSgyqvQ1W6f9e/cZrrk4mFA/fUYi9Y3+14sIAIVOF+/vSeXt3WfJLdQMRuVxmEUMYxMjzHX4U/oscRSnuZmNvEl/G6qrHXIKXbz+3Wn+3L2x3aWIiMUUQEWE/xzN5NXtKZzMLLS7lFrhKnMnfzDfIpqU87YbYa5jI1dy1gi1prBa6JNf0ul/SSgXh/vaXYqIWEgBVKQeO5Kaz5Ktyew+mWN3KbVCjJnIRPNNurCnQu39yGecuYZnjLE1W1gtZpqweGsyM/s3t7sUEbGQAqhIPZSZ72TVztN8vC8NTWBUvkAzm9Hme9zE53hSudsTruNr3jevYZ/RomaKqwN+Ts7ly0MZXB0bbHcpImIRBVCReqTIZfLR3jTe2HWa7ALd51keD9PFTXzGaPM9griws8QG8EdzFfcZ/1O9xdUxr+5IoVuzQHwc1T5Bn4i4IQVQkXpiV2I2i7cmczy9wO5SaoXLzD1MMt+kBYlV7utSDtHH/A+fGFdUQ2V105nsItb8eJb4Tg3tLkVELKAAKlLHJWUUsHRbMtuOZ9tdSq0QZSYz0VzNlXxfrf1OMN/may4jz/Cp1n7rkjU/nKVvyxAaBnjZXYqI1DAFUJE6KqfAyVu7z/DBnjSKdKNnufzMPEbyAcPMTThwVnv/4aRxG+t5lSHV3nddUeA0eXV7Cvf3ira7FBGpYQqgInWMyzT55EAGK3amkJZb/UGqzjFNrudrxpnv0ICMGt3VrebHrOdqko3wGt1PbbblcCY3XpLDpY387S5FRGqQ7vYWqUN+Ts5lyrqj/OvrkwqfFXCp+QvPm//gAXNZjYdPAG+KmGD+u8b3U9st3pqMy9RZe5G6TGdAReqA09mFLNuewleHM+0upVZoaKYywfw317DV8n33Yjvvmfv4wWht+b5ri4Nn8/nkQAZ9W4XYXYqI1BAFUJFaLL/IxZofz7Lmh7MUOHXGqDzeZgHD+ZjbzI/wwb7RAP5ovsFfmIpp6CLUuazYmcJVMYH4e3vaXYqI1AAFUJFa6stDGby6I4Uz2UV2l1Ir9DK3McH8N5GctbsULuY4/fmSD+lldyluKy3XyVu7zzI6LsLuUkSkBiiAitQyB8/k8crWZH5OzrW7lFrhYvMofzTfoD0H7C6lhLHmu3xOV7INPWxzLh/sSeX6ViFEBXvbXYqIVDMFUJFaIi23iNe/O80nv6Sj5zPKF2pmMNZcQz++wgP3+8BCyGIkH/Ayw+0uxW0VuUyWbkvm4Wub2l2KiFQzBVARN1fkNFm7J5V/7z5DTqGmzyyPwyxiKJsZYX5AAHl2l3NeQ8xPWEcvThiN7C7FbW07ns3OxGwuiw6wuxQRqUa6A17EjW09lsW97x3itR0pCp8VcIX5PQvNGUww/+324RPAgZOJ5pt2l+H2lmxN1mQKInWMzoCKuKFjafks2ZbMrsQcu0upFZqZSUwy3ySOn+wupdIu5we6mT+w1Whvdylu63h6AR/vS2NAmzC7SxGRaqIAKuJGsvKdrNp1mo/3pePUGZ9yBZg5jDbfYyCf4UntPUN8t7ma72hDkaGv5HNZtfM0PWODCfLRsEwidYG+7UTcgNNl8vG+NN7YdYbMfM1gVB4P08UAPudO831CyLK7nCprxkkG8SnvcJ3dpbit7AIXq3ae5g9X6H5ZkbpAAVTEZt8nZbNkawpH0/LtLqVW6GT+zCTzTWI5YXcp1WqUuZZNXEmGEWh3KW7r431p9GsdSkyYj92liEgVKYCK2ORkZgFLt6Ww9VjtP4Nnhcbmaf5grqYHO+0upUYEkMsYcw0vGKPsLsVtucxfH0ia3q+Z3aWISBUpgIpYLLfQxVvfn2HtnlQ92VsBvmYeI/iQm82NeFG3Z326kS9Za17DIUPjXp7L7pM5/OdoJlc0D7K7FBGpAgVQEYuYpsknv2Sw4rvTpObW7SBVLUyT6/maseYawkm3uxpLeGAyyXyDKcYDdpfi1l7dnkKXJgF4eWokQZHaSgFUxAJ7U3JZ/G0yB864/9iU7qCNeZA/mm9wCYer3Nc+bw9SHAY9cmrHw12d2MfV5g6+NLrYXYrbOplZyPt7Urm5fbjdpYjIBXLrPx+3bdvG5MmT6dixI0FBQTRu3Ji+ffuycePGUm2dTiezZs2iZcuW+Pj40LJlS2bNmoXTWfqXTk21FflvZ3IKmftFIlM/PKrwWQENzDT+6lrMs+ZTVQ6fZz0MXmjgw9RGfrwU5kO6W3/blTTB/DdeZqHdZbi1f39/lrM5upIgUlu59VfyrFmzeP311+nevTvPPPMMDz30EMnJyVx//fUsWLCgRNt77rmHhx9+mF69ejF//nx69erFww8/TEJCQql+a6qtyG8KnC5W7zrNPWsO88WhTDecidy9eJmFjDA/YLH5N/ryH4wq9FUA/DvYi4Rofz4P+PUiT46HwaqQ2vPkdGNOcysb7C7DreUVuXj9uxS7yxCRC2SYpum2vxu3bNlC165d8fH5/18cubm5XHbZZaSkpJCcnIzD4WD37t106tSJe+65h+eee6647b333ssLL7zArl276NChA0CNta2MHTt2EBcXx/bt2+nSpWYusx0/fpykpCQiIiJqpH85t5xCJw+8f4TkLJ3Bqoie5nYmmP+mEWeq3Nc3fp68FupDsqN0hDWA2SdzaVFLpjTNw5vxxuOcNULtLsVtGcA/BjSnVUM/u0sRcUspKSlERUXRtGnNPth4IbnGrc+A9ujRo0T4BPDz82PgwIGkpqaSlJQEwKpVqzBNk8mTJ5doO3nyZEzTZNWqVcXLaqqtyG/8vTy5JEK/EMsTax7nKdczTDVfqnL4POLlwfRIX55p6Ftm+AQwgSVh3lXaj5V8KeAu8227y3BrJrB4a7LdZYjIBXDrAHouiYmJOBwOGjRoAPx6r2ijRo2IjY0t0S42NpbIyEi2b99evKym2or83p1xDfFx1Mr/XjUu2MwiwbWc+eYTdGJflfrK8ICXwrx5qLEfP1ZgisaffDz5yq/2TOV4Lf+hjXnQ7jLc2r6UPD4/mGF3GSJSSbXuKfg9e/bw9ttvM3jwYAICAoBfA2mTJk3KbN+kSRNOnPj/GVNqqu25JCUlFZ+p/f17kLot3N+LYe3CWLWr6peV6wqHWcQgPmWUuZYAcqvUVxGwPsiL1cFe5HhU7o7R18J86JqbQ204F2oAk8w3mcwUMKpyZ2zd9tqOFC5vFoivl/7oE6ktalUATU9P55ZbbsHf359nn322eHlOTg5BQWUPSuzr60tGRkaNtz2XhQsXMmPGjHLbSd0zpH0DNh3IICVb94J2NX9gormaZpyscl/f+XqyNMybxAs8w3za0+C9YC9uzagdx6UNh7iOb9jIVXaX4rbO5hTxzg9nGdG5od2liEgF1ZoAmpuby6BBgzh06BDr16+nefPmxev8/f3Jzy97Hu28vDz8/PxqvO25TJw4kcGDB5dYtmfPHkaN0nR7dZ23pwej4yJ45vNEu0uxTVPzJHebq7mcH6rcV6LDYGmYD9/5Vv0S+ppgb67NLqKB022fwSxhnPkOX9KZPMPX7lLc1rs/naVvqxAiA73sLkVEKqBWXK8oKChg2LBhfPPNN6xevZrevXuXWB8dHX3Oy+EnTpwocRm9ptqeS1RUFF26dCnxuvTSS8vdTuqG7i2CaNeo/j2QFGDmcLfrTV40H6ty+Mw2YFmoN/dH+VdL+ATIN+C10NpwEf5X4aQzgg/tLsOtFTpNXtuuYZlEagu3D6BFRUXcdtttbNiwgVdffZWBAweWahMXF8epU6c4dOhQieWHDh0iOTmZuLi4Gm8rci7jukXWm9v3DNPFjebnLDb/xs1swsGFT9jgAjYEOEiI9mdtkFcVeirbl/4O9nm7/VdgsZvNjTQ2T9tdhlv76kgmP57KsbsMEakAt/72dblcjBo1infffZcXX3yR22+/vcx28fHxGIbB3LlzSyyfO3cuhmEQHx9f421FziW2gS99W4bYXUaN62DuY545k3vN1wkhq0p9/eTjwZTGfrzUwIeM3z1kFJRtMnyTi75bq+fS+eIwn1ozSYAXRfzBfMvuMtze4m+Tcbnv8NYi8n/c+h7QBx98kDfeeIPevXvj5+fH8uXLS6y//vrradSoEZ06deLuu+/m+eefJzMzkx49erBlyxaWLFnCxIkT6dixY/E2NdVW5HxGdm7IV0cyySmoHYOgV0akeYY/mG/Rkx1V7ivF0+C1UG++9i/51eTpNOm5C/psN/EuhCKHyfY2kBZUtVPLv3h78GmAgz7ZtWNKxx58RyfzZ3YZbewuxW0dTs1n0/50rm8dancpInIebh1Ad+z49RfaZ599xmeffVZq/SeffEKjRo0AmDdvHs2bN2fRokUsX76cpk2bMnPmTB566KFS29VUW5FzCfF1MLxjOMu21Z171HzNfOL5kFvMDXhTtQCXb8A7wV68H+RNwX9lynYHTQZ8ZdLgd4NOOIpgwFcmK26o+r0NK0O8uTKnCL9actJskvkmf2YaLsOtL2DZauXO03RvEUSAd+0Z81WkvnHrqTjrKk3FWT8VOU3ue/8wiRkFdpdSNabJtfyHu8x3CCetyt197u/g9VBvznqWDJONz5gM3GJy8fFzb/vSUIND0VUPoUMzCrkjvfYcl3nGCNYa19hdhlsb1DaMsV0j7S5DxFaailNEcHgajO1au/8gaG0e5lnzKR4yl1Q5fP7i7cHUSD9eCPcpET7980yGfO7intXnD58AA780Marhb+i1QV6cPMcUnu7oTvN9Akw9bHM+H/6cVvv/2BOpwxRARSwU1zSQzk0C7C6j0hqYaTzoWsJz5j+4lEPlb3AeqR4G8xv48D+N/Njn8/9fQR4uk+7fmzz4usmVP4BHBW6XjT4NXathYrEiA14N9al6RxYJIYtR5lq7y3BrRS6TJZonXsRtufU9oCJ10diuEexOyqHI5f53vzjMIm5hA7ebH+JH2ZMyVFQhv55pfCfEm9z/OtnY6pjJwC9NIlMr32+//5jsvhjyfKp2BnOrnye7fTzpkF/dAz5Vvx1cyofG1XaX4fZ2nMjmuxPZtfKPPpG6TgFUxGJNQ3zof0koa/dcQNqyUHfzO/5gvkUUVR978ls/T14N9eHUf13mDk8zGfiVSZvDF953YC703QYf9KhajQBLwrx5+mQu7vroSiIRvGQM5xujk92l1AqNg7zw1HU+EbekACpig9s6hfP5oQwy8tzvbFsL8wSTzDe4jL1V7uuolwdLQr354b9mMPIpMLl2G/TYbeJZDR/BVT+Y/KcdnA6t2lnQY14ebAh00D/LvYZlysaXVcYA3qEvRYa+tsvj5+XBLR0aMOjSBjg8a8+9vSL1ib7JRGwQ4O3JiMsasvCbU3aXUsJw8yPGmmvwpGrjlWYbsDLUmw2BXqV68sszuX+VSWAFn6E5U1hEA4cnxnmmk/J0wk1bTJbdVPWw8UaIN1dnFxHoBndIuDDYwFUsMYaRZgTbXY7bM4BrLg7mji4RhPnp15uIO9P/UBGbXNcqhPV70ziSWrV7K6vTfmKqHD5/842/o8yecn0NDkabdDxQfh9vJJ/li7QsugX7M6Zxw/O2bXMEWh812de8aiE0y8PgjVBv7kq19wnqH7mYBUY8B4wYW+uoLS6J8GN8t0haNvS1uxQRqQDdHSNiEw/DYHw39xqncKfRhi1cVuV+Aky4Pe3cAW5dd4OiCvz52yHAD4CtGTnkOssPxgO3mHhUw8NdGwK9OGbTsEwphPEPYwIPeDyk8FkB4f4OJveM4skbmyt8itQiCqAiNmrf2J8rmwfaXUYJLxvDKayGiyPXZhfRorDs0JgeaPBp5/IDXtv/C6AA0w6dAMA0Tc4Wln2PZkQqXLX7Aor9L05gaZi1wzLl48VyYyATjMf4zOhm6b5rI29Pg+Edw3lhaCw9Y3V7gkhtowAqYrMxXSPxcqMHJU4aDXnbuK7K/XgA489ze8Hnl0F6BbL3ExdFA5DvMtmWkc0LJ5KZdfQkOec4I3rdNhP/3KqfBf3e15NtvtY8D/8ZcdxlPMZyYxD5hrcl+6zNurcI4vkhsdx+WUN8HPo1JlIb6X+uiM0iA70Y3DbM7jJKWMmNnCGkyv1cmu/iqpyyz1YWehl8eFX5wTvU4SDG15vkgkL+55fjfHQmgz3ZuXx4Nr3M9r750O/b6nmCaFmYTxVnuT+/AzTnAeOv/MPjbk4bDWpwT3VDbAMfHr+hGQ/0iiYi0MvuckSkChRARdzAze3D3eqp3TzDl6XG0Grp6860ArzPkQd3tTI4HFV+H/c1jSS9yEmOaZLudJJvmuS7XJjnmIaz255f55KvqpMOgw+Cqj/opBLMs8ad3GM8zI9Gy2rvv64J8fVk0pWNmH1TDG0b+dtdjohUAwVQETfg6+XBqC7nf8rbahu4ir20qHI/EU6TQZnnfiDp/asNzHJOhDo8PBgYHoI34G3Ak7HRjGwUfs6hmTxcv84TXx3eDfaiup6HL8KTt4zruct4jI+MqzENfQWfj8PDYHDbMOYNjeX61qF4nGcoLhGpXfTtJ+Imel8UTOsIN3qK1zBYYMRTHTFuWEYhDZxl95QYYbD9kvL7uKdZI1r6+3Kpvx//ySx/ENGLT0D7X6pWfVyukydP5VIdd2X+hw78wZjOIuNWcgy/8jeo5+KaBvDs4BaM6RqJv7e7zk0lIhdKAVTETRj/NyyTO53j+dm4iM1cUeV+fEwYdZ5hmT660iC/AinvkZgoDMNgT3YemUXlT6E04GsTz3ME3/NpWuhiWkoe/3M6j8ZFVQuxR4jiEeNe/u7xF5IM9xp2yx01CfFmWt+mPHJtU6KD9UCWSF2lACriRlo19KP3Re41pMwrxs3kVcM5wJ45RbTOL/vJ9Sx/g81x5Ufvi/z+f2ikhw+eKLd9WAb02lnhEglwmYxPzWfOyVw6VXGa1Cz8+ZcRz5+Mv7HDaFulvuoDf28PxnWL5J+DWtC5SYDd5YhIDVMAFXEzd3SJwNeNhpY5a4TyhtG/Wvoan3buYZm+7AhnKvDg/VMXNyn+95lzjAf6e9fsMAnKPv9ZTA/ghqxCXkjK4casIqpywdeJB+/Tm3HG47xnXIvT0OXj8/EwoF/rUOYPjWXgpWE4PNzpGoCI1BT3+S0nIgA08Hdwcwf3GpLnLfpxivAq93NxgYtrsssOjS5Pgw+6lx8+Ajw96R8ezNjG4YR7lT9ygHch3PCfcwfQ9nlOnj6Zy4TUAoKqOAvpTi7hz8Y05nuMJNNwrwkG3FH7xv7MGdiCiVc2ItjXfUaBEJGap//xIm5ocNswNu5PJzmr0O5SACg0vFjELUw1X6pyXyPTCviPv4PcMrLmnliDA81MWh47fx8Dw0MrvL+fW8AnXUrvrFGRyZ1p+VyRW7VL7QBJNORl41a+MjpXua/6IDLQizFxEVwZE2R3KSJiEwVQETfk5enBmLgInv4s0e5Sin1hxLHLbE0n9lWpnzCXyc3pBbweWvZ9pWt7GCS8aeJRxbORyWG/9rW/ecnw6WvCzekFDMwspKojfObiw0pjAG9zHUWGvk7L4+vw4OYODRjcNgwvT12AE6nP9I0p4qaujAmifWN/fjhZ/pBDVnnRiGe++QQeVRycaWBmIRsDvTjlKH1m8lQDg/+0My94TvdcH9jYzeCb9uD6r/sJe2cXMTKtgAauqtVvAhu5iiXGUM4aoVXqqz4w+HWYsTu6RNDAX792REQBVMStje8WyYNrD1PFvFRtDhlNWW9ezQC+qFI/DmB0Wj5PNyx73NOPLzfotN/EP6/ifbo84Nu2sOFygxzfksGzVYGL8an5tCyo4mlVYA+xLDBuZ5/Rosp91QetGvpy1+WRtGqosU9F5P8pgIq4sZgwH65rFcrH+9LsLqXYUmMovc1tBJBbpX4uz3XSIc/Jbt/ST4nn+Rhs7AaDv6hY8v6l6a+X20+GlwyeYU6TUWkF9MwpqvL4qmcIZZFxM59wOWhGnnKF+TkY1aUhvS8KPueMVSJSfymAiri5EZeFs+VwBtnVcPauOmQYgSxnIBPN1VXua2xaPn9t7E9Z7+ybdnDFT9DozLm3PxsM67ob/HhRyYDjZcLgzEKGZhTgW8WzxwU4eMvox5v0J8/wKX+Des7L89fpM29uH46vl+7zFJGyKYCKuLlgXwe3dWrIkq3JdpdS7H2uYQBf0IyTVeqneaFJv6xC1geWfhzI9DB4vwdMeK90gizwgk/iDL7oBE7PkuHzypwiRqcVEHEBMyD9ty/owsvGrSQbVR+Cqj64snkgY7pGElnG8RQR+T0FUJFaoP8loWzYl8bx9HNPZ2mlIsPBSwzncfOFKvcVn17Al/4OssoYgPyXpgY/xZq0PfR/CwzY0RrWX2mQGVCyfYtCF+NS82l7jtmWKuMXmrLAiOcHo3WV+6oPYsJ8GN8tkvaN/e0uRURqCQVQkVrA4WEwtmskT2w6bncpxbYa7dlqtqMbP1apn0AX3JZewOKwsi9vf9Dd4JKjJici4P0eBscblQyewS6T29MK6JtdVOWZNdIJZKkxhPVcjWno8nF5gnw8Gdm5IX1bhuCpGYxEpBIUQEVqic5NAohrGsD249l2l1JsoXEbnc3HcFC1wdz7ZRWxIdCLY2XcM3g2xGD+LZAUTomHfzyB/pmFDE8vIKCKV9uL8ORdow8ruIlsQ2fxyuPwMOh/SSi3dQonwFtTjYpI5SmAitQi47pGsivxMEVuMi7TcaMx75nXcDObqtSPJzA2tYDHI8selimpYcmza53znIxJzadJUdU/h29pz0LjNk4YjarcV33QOTqAsd0iaBqiB7JE5MIpgIrUIlHB3gxoE8p7P6XaXUqx142B9DX/QwhZVeqnY76TrrlOtvmd+4xadJGLMakFdMmr+vSZx2jMS8Zwthrtq9xXfRAV7M3YrhF0bao57kWk6hRARWqZ4R3D+exgBunVEMKqQ7bhz1KGcK/5epX7GpOWz3d+/qUu6Pu7TIZnFNI/s7DKX1rZ+LHcGMj7XKPpMyvA39uD4R3DGXBJGA5P3ecpItVD374itYy/tycjLmvIi9+csruUYuu5mkF8xkVU7SGpxkUmN2UW8l7Qr8P4GMB1WYXcnl5AcBUfbndh8CFXs8wYSoahs3jlMQzo2zKEkZ0bEuKrXxUiUr30rSJSC/VtFcJH+9I4dDbf7lIAMA0PFhDP0+YzVe7r1vQCPvN30LTIxdjUAloUVn1YpV205kUjnkNG0yr3VR+0a+THuG6RxDYo+55cEZGqUgAVqYU8DIPx3SL520fH7C6l2G6jNV+YXejJjir142fCrFO5NKyGgeRPEc7Lxq18aXSpcl/1QUSAF6PjIujeIsjuUkSkjlMAFaml2jbyp3uLIL46nGl3KcVeNm7lCvN7vCmqUj9VDZ95ePOGcSNvcT2FhmblKY+Pw4Nh7RswpF0Y3p4a/1REap4CqEgtNrpLBNuOZVFQDWcLq0OyEc5b9GOkuc6W/ZvAZq7gFeNmzhqhttRQmxjA1bHB3BnXkHB/BXURsY4CqEgtFhHoxZB2DVj9/Rm7Syn2Jv25ga8IJ83S/e6lBQuMeH42LrJ0v7VVy3Bfxl8eySURfnaXIiL1kAKoSC03rH0DNh9I50xO1S57V5c8w4dXGMZD5hJL9neGEJYYw9jIlSVmSpKyhfk5GNm5IX0uDsbQ5yUiNlEAFanlfBwe3BkXwdwvkuwupdhmrmAQn3Iph2psH4U4eNu4jpXcSJ6hp7XL4/AwGNQ2jFs6hONXxpSnIiJWUgAVqQN6xgbz4c9p7E3JtbuUXxkGC7id58x/UBPn2LbQmZeNWzlpNKyB3uuey5sFMqZrBI2DvO0uRUQEUAAVqTPGd4vkf9YdwT0eR4J9Rgs2mldxPV9XW5+HaMKLxm3sMtpUW591WfNQH8Z1i6BjVIDdpYiIlKAAKlJHtGzoyzUXB/PJLxl2l1JsiTGUq80d+FG1AfPTCeQ1YxDr6IXL0OXj8gT5eBLfKZx+rUPx9NB9niLifhRAReqQO7pE8M3RLHKrYfag6nDWCGUVNzLOXHNB2zvx4H2u4TVjENmGf/UWVwd5ehj0ax3C7Z0aEujjaXc5IiLnpAAqUoeE+Tm4pUMDlu84bXcpxf7N9fTnS6KoXE3bacuLxm0cM6JqqLK6pVO0P+O6RtIs1MfuUkREyqUAKlLHDLq0ARv3p3Mys9DuUgAoMhy8zK08ar5YofYniGShMZxvjY41XFndEBXkxdiukXRtFmh3KSIiFaYAKlLHODwNRsdFMPvTRLtLKfaV0Zmd5iVcxt5ztsnGjxXGAN7lWooMfTWVx9/Lg1s6hDPw0jAcnrrPU0RqF33Li9RBVzQPomOUP98n5dhdSrEXjduYb87Ek5L3p7ow+IgeLDOGkGYE21Rd7WEY0OfiEO7o3JBQP32Fi0jtpG8vkTpqXLdIHnj/MC43GZfpsNGUD82eDOSz4mW7acUCI56DRjMbK6s92kT6cVe3SC4K18D7IlK7KYCK1FHNQ324oXUoH+5Ns7uUYsuMwVxjbiUHXxYZt/C50dXukmqF8AAHo7tEcHWszhCLSN2gACpSh8Vf1pAvDmeSle+0uxQAMo1AppLAIZpQYGhWnvL4OAyGtGvA0HYN8HFo/FMRqTsUQEXqsN8GJH/l22S7Sym214i1u4RaoUeLIEbHRdAwwMvuUkREqp0CqEgd1691KB/vS+NYWoHdpUgFXNTAh/HdIrm0kQbeF5G6S9d0ROo4h4fB+G6Rdpch5Qj18+RP3Rvz1E0xCp8iUufpDKhIPdAxKoCuTQPZdjzL7lLkvzg8DG66NIxbOzTA31vTZ4pI/aAAKlJPjO0awc7EbIrcZVwmoWvTQMZ2jSAqWA9kiUj9ogAqUk9EBXtz06VhvPvjWbtLqfeahngzvlsknaID7C5FRMQWCqAi9citHRvw2cF00nLdY1im+ibA24PbL2tIv9ahODw0faaI1F96CEmkHvH38mRk5wi7y6h3PAzof0ko84ddxIA2YQqfIlLv6QyoSD1z7cXBfLQ3jV/O5NldSr3QobE/47pFEhPmY3cpIiJuQwFUpJ4xjF+HZZq6/qjdpdRpjYO8GB0XwRXNg+wuRUTE7SiAitRDbSL96NEiiC2HM+0upc7xdXhwS8cGDLo0DC9P3eUkIlIWBVCRemp0XATbjmeRX6RhmaqDAVxzcTB3dIkgzE9frSIi56NvSZF6qmGAF0PaNeDNXWfsLqXWax3hy13dGtGyoa/dpYiI1AoKoCL12NB2Ddh8IJ3T2UV2l1IrNfB3cGeXCHpdFGx3KSIitYpuUBKpx3wcHoyO07BMleXtaTC8YzgvDIlV+BQRuQA6AypSz/VoEcy6n9P4OTnX7lJqhe4xQdwZF0FkoJfdpYiI1Fo6Ayoi3NUtEkNjo59XizAfHruhGQ/0jlb4FBGpIp0BFREuCvfl2otD2HQg3e5S3E6wrycjL2tI31YheCili4hUCwVQEQFgZOeGfH0kk5xCl92luAWHh8GNbUIZ3jGcAG9Pu8sREalTFEBFBIBQPwe3dgzn1e0pdpdiu7imAYztGkl0sLfdpYiI1EkKoCJS7KY2YWzYl0ZSZqHdpdiiSYg347pG0rlJgN2liLgtl8tFXl4eBQUFuFy6YuLODMMgOTmZM2cqP96zYRgEBAQQHR2Nn59ftdemACoixRyeBmO7RvKPT07YXYql/L09iO8YTv82YTg8dJ+nyLm4XC4yMzMxTRNPT098fX3x8NDzzHVRUVER2dnZHDhwgHbt2lX7cVYAFZESujYL5LLoAHYmZttdSo3zMOC6VqGMuCycYF99HYqUJy8vD9M0CQwMJDo6Gl9fzf7lzkzTxDCMCwqPTqeTEydOkJqaSlJSEk2aNKnW2vRni4iUMq5rBJ51/Exgu8b+zBnYgolXNlL4FKmggoICPD09FT7rAU9PTxo1aoSnpyfp6dU/Qoq+dUWklKahPtzQOoR1P6fZXUq1iwz0YnRcBFfFBNldikit43K58PX1VfisJ3x8fPD09KSwsPqfC1AAFZEyxXdqyBeHMsnMd9pdSrXwcXhwc/sGDG4XhrenLv6IXCjd81m/eHp6UlBQUO39KoCKSJkCfTyJ7xTOom+T7S6lSgyg10XBjOoSQQN/feWJiLgDfRuLyDn1ax3Khv3pHEnNt7uUC9KqoS/ju0XSOqL6hxAREZELp/PoInJOnh4GY7tG2F1GpYX5ObinR2P+cWNzhU8RETekACoi59UxKoArmgfaXUaFeHka3NyhAfOGxnLNxSEYmrtdROowT09PHnzwQbvLuCAKoCJSrtFxEW4/QPsVzQN5bnAL7ugcga+XvtpE3N3x48c5fPhwhV7Hjx+3tLZ169bh6enJ3LlzLd1vTdq/fz8DBw4kJCQEPz8/unXrxkcffWRbPboHVETK1TjIm0Ftw3jnh7N2l1JKTJgP47tF0r6xv92liEglFBUVcezYMTw9Pc/bzul00qxZM4uqqpuSkpLo3bs3eXl5/PnPfyY4OJglS5YwaNAgPvjgA66//nrLa1IAFZEKuaVDOJ/+kkFqbpHdpQAQ5OPJiMsacl2rkDo/aL5IXeXp6UlkZOR52yQn1+6RONzB9OnTOXnyJJ9//jlXX301ABMnTuTSSy/lvvvu44cffrC8Jl2nEpEK8fPy4I7ODe0uA4eHwcBLw5g/LJYbLglV+BQRW7355ptcccUVBAUF4e/vT1xcHKtXry5ef/LkSXx8fLjzzjvL3L5Nmza0atWqxLLNmzfTp08fQkND8fPzo23btsyfP/+Ca3znnXeIi4srDp8AYWFhjBgxgh9//FEBVETc2zUXB9OqoX0zoHSODuCZQTGM6xZJgPf5L9uJiNS0WbNmMWLECLy9vZkyZQpTp07F5XIxYsQIXnnlFQAaN25Mz549+eCDD0oN6L5t2zb279/P8OHDi5e9/vrr9O/fn9TUVO69916mT59OREQECQkJPProo5Wu8ejRo6SkpHD55ZeXWtejRw8Avvnmm0r3W1UKoCJSYYZhMK5bJFafc4wK9ubha5sw7bqmNA3xsXjvIiKlHT58mOnTpzN69Gi++OILpk2bxtSpU9m6dSvt27dn2rRpuFwuAEaMGEF6ejpvv/12iT6WLVv26/fquHEAZGdnk5CQQK9evfjuu++YMWMGU6ZM4bPPPuOGG25gzpw5nDlzplJ1Hjt2DIDo6OhS6367t9bqh7xAAVREKumSCD+ujg22ZF/+3h6Mjotg7qAWdG1aO4aCEpH6YcWKFRQWFnLXXXdx8uTJ4tfp06fp168fycnJ7Ny5E4D4+Hj8/f1ZsWJF8famabJmzRo6d+5cfAn+/fffJy0tjTFjxnDq1KkS/Q4YMID8/Hw2b95cqTqzs7MB8PUtffXK3//XhzdzcnIu5COoErcOoFlZWUyfPp1BgwYRFRWFYRiMHTu2zLZOp5NZs2bRsmVLfHx8aNmyJbNmzcLpLD2PdU21Fakv7oxriI+j5r4+DAOuaxXCvKGxDGnXAIen7vMUEfeyd+9eAHr37k2TJk1KvJ555hng16fPAQIDA+nXrx8bN24kIyMDgI0bN5KYmMhtt91W3OdPP/0EwNixY0v1ee+99wJw6tSpStUZEBAAQF5eXql1vwXP34Koldz6KfjTp08zY8YMoqKi6Nq1K2vXrj1n23vuuYcFCxYwbtw4unfvzldffcXDDz/MsWPHSt24W1NtReqLcH8vhrVvwKqdp6u977aN/BjfLZLYBvbdayoiUp7fLq8vW7aMkJCQMtt069at+N+jRo1izZo1rFixgkmTJrF8+XIcDgejR48u1efs2bNp3bp1mX127NixUnX+dpk9MTGx1LrfLs83bdq0Un1WB7cOoFFRURw/fpwmTZpQVFSEl5dXme12797Niy++SEJCAs899xwAEyZMICgoiBdeeIFJkybRoUOHGm0rUt8MaRfG5gPpJGcVVkt/EQFe3BnXkB4trLm8LyJSFS1btgSgSZMm9OnTp9z2gwYNIjw8nJUrVzJ+/HjWrl1Lr169aNSoUXGb30JnaGgogwYNqpY6mzdvTkREBN9++22pdVu2bAHgyiuvrJZ9VYZbX4L38fGhSZMm5bZbtWoVpmkyefLkEssnT56MaZqsWrWqxtuK1Dfenh7c2aXq88T7OAxu7xTOc0NaKHyK1DNOp5Pk5OTzvtz1lreRI0ficDh49NFHSz3dDqXPODocDoYMGcLXX3/NwoULSUtLY8SIESXaDB06lJCQEGbPnl18qf73kpKSME2z0rUOHTqU7du3FwdOgLS0NFauXEnbtm1p3759pfusKrc+A1pR27Zto1GjRsTGxpZYHhsbS2RkJNu3b6/xtueSlJRUfA/Ib/bs2VPh9ybizrq3CGL9Xj9+PJV7Qdv3jA3izi4RhAeUfXVDROouh8NR4RmOHA574sr69es5efJkqeVXXXUVQ4YM4bHHHmPq1Km0a9eOYcOGER0dTWJiIlu3bmX//v2lni4fPXo0ixcvZurUqQQEBBAfH19ifXBwMPPmzWPcuHG0adOG+Ph4YmJiSE5OZteuXWzatInMzMxzXhE+l+nTp/Pee+8xaNAgJk2aREhICEuWLOHMmTMsW7as8h9MNagTATQxMfGcZ0qbNGnCiRMnarztuSxcuJAZM2aU206kthrfLZIHPzhCZf4ovzjcl/HdImkT6VdzhYmIW7PjvsPK2rBhAxs2bCi1fPz48QwZMoQpU6bQrl075syZw8svv0xubi7h4eG0bduW6dOnl9quZ8+exMTEcOTIEYYNG1b8gNDvjRw5kpiYGGbOnMny5cvJyMggLCyMVq1aMWPGjAsK49HR0Xz++edMnjyZefPmUVBQQPv27Xnvvfe44YYbKt1fdagTATQnJ4egoKAy1/n6+pY4jV1Tbc9l4sSJDB48uMSyPXv2MGrUqHK3FakNWjTw5bqWIWzYn15u21A/B3d0bkifi4MxDD3ZLiLuacCAARW+9D9w4EAGDhxY4b4PHjxYbpsePXqwbt26cttV5vaE1q1bV6hPq9SJAOrv709+fn6Z6/Ly8vDz86vxtucSFRVFVFRUue1EarMRnRuy5UgmOQWuMtf/Nn3mLR0b4O+lGYxEROo7t34IqaKio6PPeTn8xIkTJS6j11RbkfosxNfB8I7hZa7r1iyQuYNbcGdchMKniIgAdSSAxsXFcerUKQ4dOlRi+aFDh0hOTiYuLq7G24rUdwMuCSM62Lv45+ahPvz9+qb8T58mRP1uuYiISJ0IoPHx8RiGwdy5c0ssnzt3LoZhlHjKrKbaitR3Dk+DsV0jCPTxZMLlkcwZGEPHqNI32IuIiLj9PaDz5s0jLS2teHaA77//nieeeAKAwYMH07FjRzp16sTdd9/N888/T2ZmJj169GDLli0sWbKEiRMnlpg1oKbaigjENQ1kwc2xutQuIiLn5fYBdM6cORw5cqT45++++47vvvsO+HUIh99C4Lx582jevDmLFi1i+fLlNG3alJkzZ/LQQw+V6rOm2ooICp8iIlIuw7yQIfWlSnbs2EFcXBzbt2+nS5cuNbKP48ePk5SURERE1WeqERERATh79iyBgYHF01CKezNNE8Mw8PC48Dsu9+3bR25uLp06dTpnmwvJNXXiHlARERERqT0UQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiEgt5OnpyYMPPmh3GRdEAVRERETkd9atW4enp2epiWhqq88++4yxY8dy2WWX4evri2EYrFu3ztaa3H4cUBEREal7pvx7N6k5BRVqG+bvzVO3dKjhiuqu9957j+XLl3PRRRfRunVrdu/ebXdJCqAiIiJivdScAr4+eAavcsaoLHS5uOqicIuqqpvuu+8+pk+fTlBQEM8++yz333+/3SXpEryIiIjYw8vDg5hw//O+yguodnvzzTe54oorCAoKwt/fn7i4OFavXl28/uTJk/j4+HDnnXeWuX2bNm1o1apViWWbN2+mT58+hIaG4ufnR9u2bZk/f/4F19i0aVOCgoIuePua4N5HVURERMRNzZo1ixEjRuDt7c2UKVOYOnUqLpeLESNG8MorrwDQuHFjevbsyQcffEBBQclbDrZt28b+/fsZPnx48bLXX3+d/v37k5qayr333sv06dOJiIggISGBRx991NL3V5MUQEVEREQq6fDhw0yfPp3Ro0fzxRdfMG3aNKZOncrWrVtp374906ZNw+VyATBixAjS09N5++23S/SxbNkyDMNg3LhxAGRnZ5OQkECvXr347rvvmDFjBlOmTOGzzz7jhhtuYM6cOZw5c8by91oTFEBFREREKmnFihUUFhZy1113cfLkyeLX6dOn6devH8nJyezcuROA+Ph4/P39WbFiRfH2pmmyZs0aOnfuXHwJ/v333yctLY0xY8Zw6tSpEv0OGDCA/Px8Nm/ebMfbrXZ6CElERESkkvbu3QtA7969z9kmKSkJgMDAQPr168eHH35IRkYGwcHBbNy4kcTERBISEorb//TTTwCMHTv2nH2eOnWqGqq3nwKoiIiISCX9dnl92bJlhISElNmmW7duxf8eNWoUa9asYcWKFUyaNInly5fjcDgYPXp0qT5nz55N69aty+yzY8eO1fUWbKUAKiIiIlJJLVu2BKBJkyb06dOn3PaDBg0iPDyclStXMn78eNauXUuvXr1o1KhRcZvfQmdoaCiDBg2qmcLdhO4BFREREamkkSNH4nA4ePTRR0s93Q6QmJhY4meHw8GQIUP4+uuvWbhwIWlpaYwYMaJEm6FDhxISEsLs2bPJyMgo1WdSUhKmaVbvG7GJzoCKiIiILQpdLo6cySm3jV3Wr1/PyZMnSy2/6qqrGDJkCI899hhTp06lXbt2DBs2jOjoaBITE9m6dSv79+/n+PHjJbYbPXo0ixcvZurUqQQEBBAfH19ifXBwMPPmzWPcuHG0adOG+Ph4YmJiSE5OZteuXWzatInMzEy8vLwq9T727dvHokWLAIofjFq2bBmffvop8Oslf6spgIqIiIjlwvy9KzzDUZi/dw1XU7YNGzawYcOGUsvHjx/PkCFDmDJlCu3atWPOnDm8/PLL5ObmEh4eTtu2bZk+fXqp7Xr27ElMTAxHjhxh2LBhBAQElGozcuRIYmJimDlzJsuXLycjI4OwsDBatWrFjBkzcDgqH90OHDjA008/XWLZm2++WfxvBVARERGpF9x5bvcBAwbgdDor1HbgwIEMHDiwwn0fPHiw3DY9evRg3bp15baraI0DBgxwu0v3ugdURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgFURERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERERqIU9PTx588EG7y7ggDrsLEBERkfrHeO8vkHOmYo39wzEHz6vZgn5n3bp1DBo0iGeeeYbJkydbtt+a4HK5WLBgAe+99x4//PADZ86coVGjRvTo0YMnn3ySFi1a2FKXAqiIiIhYL+cMHP4SPL3O385ZCC2utqamOigrK4u//OUvtG3blttvv51mzZrx888/8+qrr7J+/Xr+85//0KpVK8vrUgAVERERe3h6QYOLzt/m7EFraqmjfHx8WL9+PTfccEOJ5TfddBODBw/mySefZMmSJZbXpXtARURERC7Qm2++yRVXXEFQUBD+/v7ExcWxevXq4vUnT57Ex8eHO++8s8zt27RpU+oM5ObNm+nTpw+hoaH4+fnRtm1b5s+ff0H1+fj4lAqfAIMGDSIkJISff/75gvqtKgVQERERkQswa9YsRowYgbe3N1OmTGHq1Km4XC5GjBjBK6+8AkDjxo3p2bMnH3zwAQUFBSW237ZtG/v372f48OHFy15//XX69+9Pamoq9957L9OnTyciIoKEhAQeffTRaqs9LS2NnJwcGjZsWG19VoYCqIiIiEglHT58mOnTpzN69Gi++OILpk2bxtSpU9m6dSvt27dn2rRpuFwuAEaMGEF6ejpvv/12iT6WLVuGYRiMGzcOgOzsbBISEujVqxffffcdM2bMYMqUKXz22WfccMMNzJkzhzNnKvjgVjmmT59OYWEhI0eOrJb+KksBVERERKSSVqxYQWFhIXfddRcnT54sfp0+fZp+/fqRnJzMzp07AYiPj8ff358VK1YUb2+aJmvWrKFz587Fl+Dff/990tLSGDNmDKdOnSrR74ABA8jPz2fz5s1Vrv2tt97ihRdeoF+/fowYMaLK/V0IPYQkIiIiUkl79+4FoHfv3udsk5SUBEBgYCD9+vXjww8/JCMjg+DgYDZu3EhiYiIJCQnF7X/66ScAxo4de84+T506VaW6N2/ezJgxY2jXrh1vvvlmlfqqCgVQERERkUr67fL6smXLCAkJKbNNt27div89atQo1qxZw4oVK5g0aRLLly/H4XAwevToUn3Onj2b1q1bl9lnx44dL7jmr7/+mmHDhhEdHc3GjRvPWbcVFEBFREREKqlly5YANGnShD59+pTbftCgQYSHh7Ny5UrGjx/P2rVr6dWrF40aNSpu81voDA0NZdCgQdVa744dOxgwYAAhISFs3LiRyMjIau2/snQPqIiIiNjDWfjrOJ/nezkL7a6yTCNHjsThcPDoo4+WerodIDExscTPDoeDIUOG8PXXX7Nw4ULS0tJK3X85dOhQQkJCmD17NhkZGaX6TEpKwjTNStf6448/0r9/f3x8fNiwYQMxMTGV7qO66QyoiIiIWM8/vOIzHPmH12wt57B+/XpOnjxZavlVV13FkCFDeOyxx5g6dSrt2rUrvrSdmJjI1q1b2b9/P8ePHy+x3ejRo1m8eDFTp04lICCA+Pj4EuuDg4OZN28e48aNo02bNsTHxxMTE0NycjK7du1i06ZNZGZm4uVVzuxRv5Oenk6/fv1ISUkhISGBzZs3l3iQKSgoiFGjRlXyk6k6BVARERGxnJVzu1+oDRs2sGHDhlLLx48fz5AhQ5gyZQrt2rVjzpw5vPzyy+Tm5hIeHk7btm2ZPn16qe169uxJTEwMR44cYdiwYQQEBJRqM3LkSGJiYpg5cybLly8nIyODsLAwWrVqxYwZM3A4KhfdkpOTi8/GPv/886XWR0dHK4CKiIiI2G3AgAE4nc4KtR04cCADBw6scN8HD5Y/tWiPHj1Yt25due0qUmOrVq0u6LJ9TdM9oCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiUgt5enry4IMP2l3GBXHYXYCIiIjUP3//6u+k5qdWqG2YTxgzus+o4Yr+37p16xg0aBDPPPMMkydPtmy/NeX5559n5cqVHDhwgPT0dEJDQ2nTpg0PP/wwN954oy01KYCKiIiI5VLzU9l2chsOj/NHkSJXEV0bd7Woqrppx44dNG7cmOuuu46GDRuSnJzM6tWruemmm1i8eDFjx461vCYFUBEREbGFw8NB8+Dm521zNOOoRdXUXUuXLi21bMqUKVx00UXMnTvXlgCqe0BFRERELtCbb77JFVdcQVBQEP7+/sTFxbF69eri9SdPnsTHx4c777yzzO3btGlDq1atSizbvHkzffr0ITQ0FD8/P9q2bcv8+fOrte7g4GDCwsLIyMio1n4rSgFURERE5ALMmjWLESNG4O3tzZQpU5g6dSoul4sRI0bwyiuvANC4cWN69uzJBx98QEFBQYntt23bxv79+xk+fHjxstdff53+/fuTmprKvffey/Tp04mIiCAhIYFHH320SvWmpKSQmJjIjh07mDRpEgcOHODaa6+tUp8XSpfgRURERCrp8OHDTJ8+ndGjR7NkyZLi5VOmTKFr165MmzaNcePG4eHhwYgRI/jkk094++23uf3224vbLlu2DMMwGDduHADZ2dkkJCTQq1cvNmzYgGEYxX0OGDCAOXPmcO+99xIeHn5BNV922WUkJiYC4OPjw6hRo3j++ecv9COoEp0BFREREamkFStWUFhYyF133cXJkyeLX6dPn6Zfv34kJyezc+dOAOLj4/H392fFihXF25umyZo1a+jcuXPxJfj333+ftLQ0xowZw6lTp0r0O2DAAPLz89m8efMF17x06VLefvttnnnmGdq3b09WVhbZ2dlV+hwulM6AioiIiFTS3r17Aejdu/c52yQlJQEQGBhIv379+PDDD8nIyCA4OJiNGzeSmJhIQkJCcfuffvoJ4LwPBZ06deqCa77++uuL/33PPffQuXNnbrzxRrZt23bBfV4oBVARERGRSnK5XMCvl9FDQkLKbNOtW7fif48aNYo1a9awYsUKJk2axPLly3E4HIwePbpUn7Nnz6Z169Zl9tmxY8dqqd/Ly4shQ4bw5JNP8sMPP9C+fftq6beiFEBFREREKqlly5YANGnShD59+pTbftCgQYSHh7Ny5UrGjx/P2rVr6dWrF40aNSpu81voDA0NZdCgQTVT+O/k5eUBcObMmRrf13/TPaAiIiJiiyJXEUczjp73VeQqsrvMMo0cORKHw8Gjjz5a6ul2oPhhn984HA6GDBnC119/zcKFC0lLS2PEiBEl2gwdOpSQkBBmz55d5vBISUlJmKZZqToLCwtJTk4utTw1NZW33noLPz8/OnfuXKk+q4POgIqIiIjlwnzCKjzDUZhPWA1XU7b169dz8uTJUsuvuuoqhgwZwmOPPcbUqVNp164dw4YNIzo6msTERLZu3cr+/fs5fvx4ie1Gjx7N4sWLmTp1KgEBAcTHx5dYHxwczLx58xg3bhxt2rQhPj6emJgYkpOT2bVrF5s2bSIzMxMvL68Kv4eMjAxiYmIYMGAAbdu2pUGDBhw+fJhVq1aRnJzM7NmzCQ4OvrAPqAoUQEVERMRyVs7tfqE2bNjAhg0bSi0fP348Q4YMYcqUKbRr1445c+bw8ssvk5ubS3h4OG3btmX69OmltuvZsycxMTEcOXKEYcOGERAQUKrNyJEjiYmJYebMmSxfvpyMjAzCwsJo1aoVM2bMwOGoXHQLDAxk1KhRbNmyhQ0bNpCTk0NISAiXXXYZ9957L4MHD65Uf9VFAVRERETkdwYMGIDT6axQ24EDBzJw4MAK933w4MFy2/To0YN169aV264iNfr4+PDyyy9XqDYr6R5QEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERGphTw9PXnwwQftLuOCOOwuoDZwOp08/fTTLFq0iGPHjtGsWTMmTJjAX//6Vzw9Pe0uT0REpNY5OW0aRalpFWrrCAul8RNP1GxBv7Nu3ToGDRrEM888w+TJky3br1Vuvvlm3nnnHbp06cL27dttqUEBtALuueceFixYwLhx4+jevTtfffUVDz/8MMeOHWP+/Pl2lyciIlLrFKWmkfvtt+AoJ4oUFeF3+eXWFFUPrF+/nvfeew8fHx9b61AALcfu3bt58cUXSUhI4LnnngNgwoQJBAUF8cILLzBp0iQ6dOhgc5UiIiK1kMOBd0zz8zYpOHLUomLqvsLCQu655x7i4+P59NNPba1F94CWY9WqVZimWeoU/OTJkzFNk1WrVtlTmIiIiNjuzTff5IorriAoKAh/f3/i4uJYvXp18fqTJ0/i4+PDnXfeWeb2bdq0oVWrViWWbd68mT59+hAaGoqfnx9t27atliuujz/+OCkpKfzzn/+scl9VpQBajm3bttGoUSNiY2NLLI+NjSUyMtK2eydERETEXrNmzWLEiBF4e3szZcoUpk6disvlYsSIEbzyyisANG7cmJ49e/LBBx9QUFBQYvtt27axf/9+hg8fXrzs9ddfp3///qSmpnLvvfcyffp0IiIiSEhI4NFHH73gWg8ePMgzzzzDI488QqNGjS64n+qiS/DlSExMpEmTJmWua9KkCSdOnDjv9klJSSQlJZVYtmfPnmqr73ycTicpKSmW7EtEROo+wzAAME2zGnqrTB9mNe2z8s6138OHDzN9+nRGjx7N4sWLi5dPmTKFrl27Mm3aNMaOHYuHhwcjRozgk08+4d///je33357cdtly5ZhGAZjx47FNE2ys7NJSEigV69efPzxx8Wf90MPPcRNN93EnDlzSEhIIDw8vEI1/t6f/vQnYmJieOCBBy7kY6h2CqDlyMnJISgoqMx1vr6+ZGRknHf7hQsXMmPGjJoo7bwcDgdNmza1fL8iIlJ3JScnA/8fRKvCoOJ9GBjVss8K7+93+zrXfleuXElhYSF33XUXp06dKrGuX79+PPPMM+zatYsuXboQHx/P5MmTWblyJSNGjAB+DY1r1qyhc+fOtG7dGoC1a9eSlpbGmDFjij/r3wwYMICPPvqITz75pMQZ0/PV+Ju3336bjz/+mI8//thtRu9RAC2Hv78/+fn5Za7Ly8vDz8/vvNtPnDiRwYMHl1i2Z88eRo0aVW01lqVx48Y12r+IiNQ/Z86cAcDDozrv4KtYsKzefZ7fb4HOMIxz7nfv3r0A9O7d+5z9nDx5Eg8PD4KDg7nhhhtYt24dmZmZhISE8PHHH5OYmMi9995bvI/frpCOHTv2nH2eOnWqRE3nqxEgNzeX++67j6FDh3Ldddeds53VFEDLER0dza5du8pcd+LECTp37nze7aOiooiKiqqJ0kRERMQmLpcLgFdffZXg4OAy21z+u+GjRo0axTvvvMOKFSv44x//yGuvvYbD4WDMmDHFbZxOJwCzZ88uPiv63zp16lSpOp966imSkpKYNGkSP/74Y/HyoqIi8vPz+fHHH2nQoIHlWUUBtBxxcXF8/PHHHDp0qMSDSIcOHSI5OZm4uDgbqxMRERE7/PbkepMmTbj22mvLbT948GDCw8NZsWIF48ePZ+3atfTq1avEA0GXXHIJAGFhYQwZMqRa6jx27BiFhYXccMMNpdYlJyfTvn17Ro8ezbJly6plfxWlp+DLER8fj2EYzJ07t8TyuXPnYhgG8fHx9hQmIiJS2xUVUXDkyHlfFBXZXWWZRo4cicPh4NFHHy3zVr3/fkjZ4XAwZMgQvv76a1588UXS0tIYOXJkiTZDhw4lJCSEp556ivT09FJ9JiYmFp95rag//OEPLFmypNQrLCyM2NhYlixZwqRJkyrVZ3XQGdBydOrUibvvvpvnn3+ezMxMevTowZYtW1iyZAkTJ06kY8eOdpcoIiJS63iGheFfwRmOPMPCariasn344YelRrIB6N69O0OHDuXxxx/nkUceoW3bttx8881ER0eTmJjIt99+y/79+0lMTCyx3ZgxY1i8eDFTp04lICCgxBPxACEhIfzrX/9izJgxXHLJJdx+++3ExMSQnJzMzp072bRpE9nZ2ZW6H/bKK6/kyiuvLLV86tSphIWFnfd+05qkAFoB8+bNo3nz5ixatIjly5fTtGlTZs6cyUMPPWR3aSIiIrVS9JMz7S6hXBs2bGDDhg2llo8fP56hQ4fyP//zP7Rt25Y5c+bw0ksvkZubS3h4OG3btmX69OmltuvVqxctWrTg8OHD3HzzzQQEBJRqM3LkSJo3b84TTzzBa6+9RkZGBmFhYbRq1YrHHnvMbZ5iryrDtGtgrXpsx44dxMXFsX37drp06WJ3OSIiIhWya9cu/Pz8zvmAjNQ9+/btIzc397wPP11IrtE9oCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABUREZEKMQyj0gOhS+3mdDoxDKPa+1UAFRERkQrx8vKisLCQ3Nxcu0sRC+Tn5+N0OnE4qn/YeAVQERERqZCwsDBcLheJiYkKoXWc0+nk1KlTOJ1OQkJCqr1/zYQkIiIiFRIZGUlGRgZZWVkcOHAALy+vSk0LKbVHUVERRUVFeHh4EBUVVe39K4CKiIhIhXh4eNCyZUuSk5NJTU2loKAATahYNxmGQUBAAE2aNKmRPzIUQEVERKTCPDw8aNy4MY0bN7a7FKnFdN5cRERERCylACoiIiIillIAFRERERFLKYCKiIiIiKUUQEVERETEUnoK3ga/Dd67Z88emysRERERqZrf8kxlJidQALXB4cOHARg1apS9hYiIiIhUk8OHD9OjR48KtTVMjSBrudOnT/PRRx/RokUL/Pz8amQfe/bsYdSoUSxfvpxLL720RvYhlaNj4l50PNyPjon70TFxL+56PHJzczl8+DA33HADDRs2rNA2OgNqg4YNG3LHHXdYsq9LL72ULl26WLIvqRgdE/ei4+F+dEzcj46Je3HH41HRM5+/0UNIIiIiImIpBVARERERsZQCqIiIiIhYSgG0joqKiuLvf/87UVFRdpci/0fHxL3oeLgfHRP3o2PiXurS8dBT8CIiIiJiKZ0BFRERERFLKYCKiIiIiKUUQEVERETEUgqgIiIiImIpBVARERERsZQCqIiIiIhYSgG0jnE6ncyaNYuWLVvi4+NDy5YtmTVrFk6n0+7SaqWsrCymT5/OoEGDiIqKwjAMxo4dW2bbynz2NdW2rtu2bRuTJ0+mY8eOBAUF0bhxY/r27cvGjRtLtdXxqHl79uzh9ttvp1WrVgQGBhIcHMxll13G3Llzyc/PL9FWx8MemzdvxjAMDMPgwIEDJdbpmNS8w4cPF3/+//2aMGFCibb17niYUqf88Y9/NAFz3Lhx5ssvv2yOGzfOBMw//elPdpdWKx06dMgEzKioKHPgwIEmYI4ZM6bMtpX57GuqbV13yy23mA0bNjQnTpxoLly40HzmmWfM9u3bm4D5r3/9q0RbHY+a99FHH5nXX3+9OW3aNPPFF18058+fb44cOdI0DMMcOHBgibY6HtbLz88327RpYwYEBJiAuX///hLrdUxq3m+/Q4YMGWK+9tprJV5ff/11ibb17XgogNYh33//vWkYhpmQkFBieUJCgmkYhvn999/bVFntlZeXZx4/ftw0TdMsLCw8ZwCtzGdfU23rgy+//NLMy8srsSwnJ8ds3bq1GRYWZhYWFpqmqeNhtz//+c8mYP7888+maep42OXJJ580IyMjzcmTJ5cKoDom1vgtgE6dOvW87erj8VAArUMeeeQREzAPHjxYYvnBgwdNwHzkkUdsqqxuOF8ArcxnX1Nt67P777/fBMyjR4+apqnjYbenn37aBMxvvvnGNE0dDzscPnzY9Pf3NxcvXmz+/e9/LxVAdUys8fsAmpOTY+bk5JTZrj4eD90DWods27aNRo0aERsbW2J5bGwskZGRbN++3abK6r7KfPY11bY+S0xMxOFw0KBBA0DHw2o5OTmcPn2aI0eOsHr1ambPnk10dDQdO3YEdDzskJCQQMeOHc95z7qOibWee+45/P398ff3p1WrVsyfP7/E+vp4PBy27VmqXWJiIk2aNClzXZMmTThx4oTFFdUflfnsa6ptfbVnzx7efvttBg8eTEBAAKDjYbXZs2czY8aM4p+vuOIKXnrpJfz8/AAdD6utXbuWtWvX8u2332IYRpltdEys4eHhQd++fRk6dCgxMTEkJiayaNEi/vKXv3D48GGefvppoH4eDwXQOiQnJ4egoKAy1/n6+pKRkWFxRfVHZT77mmpbH6Wnp3PLLbfg7+/Ps88+W7xcx8Nao0eP5uqrr+bMmTNs3ryZ77//nrNnzxav1/GwTm5uLgkJCUyYMIG4uLhzttMxsUbz5s1LjdIxYcIErr32Wv75z38yadIkLr744np5PHQJvg7x9/cvNfTJb/Ly8orPRkj1q8xnX1Nt65vc3FwGDRrEoUOHWLNmDc2bNy9ep+NhrYsuuojrrruO+Ph4Fi5cyG233Ua/fv3Ys2cPoONhpZkzZ5KWlsbMmTPP207HxD6enp48+OCDuFwuNm3aBNTP46EAWodER0ef83T6iRMnznkaXqquMp99TbWtTwoKChg2bBjffPMNq1evpnfv3iXW63jYa+TIkRQWFrJ8+XJAx8MqiYmJzJkzh7vvvpu0tDQOHDjAgQMHis9GHz16lIMHDwI6JnaLiYkB4PTp00D9PB4KoHVIXFwcp06d4tChQyWWHzp0iOTk5PNejpGqqcxnX1Nt64uioiJuu+02NmzYwKuvvsrAgQNLtdHxsFdubi4AqampgI6HVZKTk8nPz+epp56iVatWxa8XXngBgL59+xY/GKZjYq/fJgVo1KgRUE+Ph23P30u127lz53nH+9q1a5dNldUN5xuGqTKffU21rQ+cTqcZHx9vAuZLL710znY6HtY4depUmcv/+te/moC5dOlS0zR1PKySlpZmrl69utRr+PDhJmC+8MIL5jvvvGOapo6JVc6cOVNqWU5Ojtm5c2fTy8ureOi4+ng8FEDrmIkTJxbPeLBo0aLiGQ8mTpxod2m11gsvvGA+/vjj5owZM0zA7Ny5s/n444+bjz/+eIn/vJX57GuqbV133333mYDZu3fvUrOKvPbaa+bJkyeL2+p41LyhQ4eaPXv2NP/2t7+ZL730kjl79myzb9++JmBeffXVxRMDmKaOh53KGgfUNHVMrDBs2DDzhhtuMP/+97+bL7/8sjljxgzzoosuMgHzH//4R4m29e14KIDWMYWFhebMmTPN2NhY08vLy4yNjTVnzpxZ4heBVE5MTIwJlPlasmRJcbvKfPY11bau69279zmPBWB+8sknxW11PGreqlWrzP79+5vR0dGml5eXGRgYaHbt2tV8+umnS81YpeNhn3MFUB2Tmrdo0SKzZ8+eZmRkpOlwOMzQ0FDz2muvNd99991Sbevb8TBM0zSr8Yq+iIiIiMh56SEkEREREbGUAqiIiIiIWEoBVEREREQspQAqIiIiIpZSABURERERSymAioiIiIilFEBFRERExFIKoCIiIiJiKQVQEREREbGUAqiIiIiIWEoBVEREREQspQAqIlIHXHPNNRiGgWEYXHnlldXe/5VXXlncf9OmTau9fxGpXxx2FyAiItWjTZs2TJ06lYiIiGrve8aMGaSkpDBz5kwyMzOrvX8RqV8M0zRNu4sQEZGqueaaawD49NNPa3w/Bw4c4Pjx4zW6HxGp23QJXkREREQspQAqImKzgoICOnfuTGRkJKdOnSqx7rbbbsPb25sdO3ZccP8tWrTg6quvZseOHfTu3Rt/f3+aNWvGvHnzADh06BCDBg0iODiYiIgIpk2bhi6OiUhNUgAVEbGZt7c3K1asICsri/HjxxcvX7ZsGatXr+bxxx+nS5cuVdpHYmIiN910E5dffjlPP/00UVFR3HPPPSxdupQ+ffoQExPDU089RYcOHZg5cyavvfZaVd+WiMg56R5QERE3MX/+fP7yl78wb948BgwYQKdOnejSpQubN2/Gw+P85wvOdw9oixYtOHLkCGvWrGHIkCEAnD59mqZNm1JQUMD8+fP54x//CEBeXh7NmjWjdevWbNmypcz96B5QEakqnQEVEXETf/7zn7npppv461//yrBhw/D09OTVV18tN3xWRFRUVHH4BGjYsCEtW7bE09OTu+66q3i5r68vcXFxHDhwoMr7lP9t7251GgnDKACfpCkC05omCFIcV0BdBa4OLgFEQxMuAcUVUFGP4kfXV1XUEMSEK0AQHKRJBUkFiE3WsCs2O0wbeB75ijOfPPlm8g7wNwoowBq5vLxMrVZLURQZjUZpt9ul5O7s7HyaNZvNbG1tZWNj49P85eWllOcC/IkCCrBGptNpFotFkqQoitJya7XaP819nQV8JQUUYE08PT1lMBik0+mk3+/n4uLiy/d6AqyCPyEBrIH39/ccHx/n7e0tV1dX2d7eznQ6zdHRUYqiSLPZXPURAUrjBhRgDQyHw0wmkwyHw+zu7mZzczPX19d5fn7O6enpqo8HUCoFFGDFHh4ecnZ2loODg5ycnPye7+3t5fz8PLe3t7m5uVnhCQHKZQ8owDewv7+f5XKZ8Xicer2eRqNRav58Ps9yuczh4WEeHx/tAQX+ixtQgG9iNpul1Wql1+uVnt3r9dJqtTKbzUrPBn4eN6AA38D9/X1eX1+TJI1GI51Op9T8u7u7zOfzJL+W1Xe73VLzgZ9FAQUAoFJewQMAUCkFFACASimgAABUSgEFAKBSCigAAJVSQAEAqJQCCgBApRRQAAAqpYACAFApBRQAgEopoAAAVOoDzXUwcKh3kbYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 750x750 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(6,6), facecolor='w', dpi=125)\n",
    "\n",
    "# Set any additional items to plot\n",
    "case.popup_storteddata['plotdomain']['plot_turbines']        = case.listboxpopupwindict['listboxactuator'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_refineboxes']     = case.listboxpopupwindict['listboxtagging'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes']    = [] #case.listboxpopupwindict['listboxsampling'].getitemlist() \n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes_style'] = \"{'markersize':.25, 'marker':'.', 'linestyle':'None', 'alpha':0.1}\"\n",
    "case.popup_storteddata['plotdomain']['plot_chooseview']      = 'XY'\n",
    "case.plotDomain(ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5c06257b-9da6-47cb-991d-8309fcc6554a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Refinement T0_level_0_zone: level 1: 6601240 cells\n",
      "Refinement T0_level_1_zone: level 2: 8641624 cells\n",
      "Refinement T0_level_2_zone: level 3: 14562737 cells\n",
      "Refinement T0_level_3_zone: level 4: 36870930 cells\n",
      "ESTIMATED MESH SIZE\n",
      "   Level       Ncells                      Cell Size\n",
      "       0     50331648             10.0 x 10.0 x 10.0\n",
      "       1      6601240                5.0 x 5.0 x 5.0\n",
      "       2      8641624                2.5 x 2.5 x 2.5\n",
      "       3     14562737             1.25 x 1.25 x 1.25\n",
      "       4     36870930          0.625 x 0.625 x 0.625\n",
      "  TOTAL:    117008179\n"
     ]
    }
   ],
   "source": [
    "case.estimateMeshSize()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9696fc9a-35f1-4ca8-959e-75d63e813ff6",
   "metadata": {},
   "source": [
    "## Add sampling planes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f388c0c8-29ee-4833-8198-eba9f4865094",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First delete everything that already exists\n",
    "case.listboxpopupwindict['listboxsampling'].deleteall()\n",
    "case.listboxpopupwindict['listboxpostprosetup'].deleteall()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3abe6496-05b9-4314-a787-1094aeff1061",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "postprocessing_setup_name: 'metmast_'\n",
      "postprocessing_setup_type: 'Sampling'\n",
      "postprocessing_setup_output_frequency: 1\n",
      "postprocessing_setup_fields: ['velocity', 'temperature', 'tke']\n",
      "postprocessing_setup_derived_fields: None\n",
      "postprocessing_setup_averaging_window: None\n",
      "postprocessing_setup_averaging_start_time: None\n",
      "postprocessing_setup_averaging_stop_time: None\n"
     ]
    }
   ],
   "source": [
    "## virtual metmast measurements\n",
    "metmastpprosetup = case.get_default_postprosetupdict()\n",
    "metmastpprosetup['postprocessing_setup_name'] = 'metmast_'\n",
    "metmastpprosetup['postprocessing_setup_type'] = 'Sampling'\n",
    "metmastpprosetup['postprocessing_setup_output_frequency'] =  1\n",
    "metmastpprosetup['postprocessing_setup_fields']           =  ['velocity', 'temperature', 'tke']\n",
    "case.add_postprosetup(metmastpprosetup, verbose=True)\n",
    "\n",
    "sampledict = case.get_default_samplingdict()\n",
    "sampledict['sampling_name']     = 'virtualmast'\n",
    "sampledict['sampling_outputto'] = 'metmast_'\n",
    "sampledict['sampling_type']     = 'LineSampler'\n",
    "sampledict['sampling_l_num_points'] = 20\n",
    "sampledict['sampling_l_start']      = [1800, 1800, 10.0]\n",
    "sampledict['sampling_l_end']        = [1800, 1800, 200.0]\n",
    "case.add_sampling(sampledict, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "80db1da6-af78-4b41-af4d-fdb470484568",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputoptions=\"outputvars:velocity;tke;temperature outputfreq:50\"\n",
    "samplingcsv=\"\"\"\n",
    "# CSV file should have columns withturbinescsv\n",
    "# name, type, upstream, downstream, lateral, below, above, n1, n2, options\n",
    "name,      type, upstream, downstream, lateral, below, above, n1, n2,  options\n",
    "rotorplaneUP,  rotorplane, 4,     0,       2,    0.7,      1,  11, 11,           usedx:0.05 outputto:rotorplaneUP_  orientation:nacdir {outputoptions} noffsets:4\n",
    "rotorplaneDN,  rotorplane, 0,     10,      2,    0.7,      1,  11, 11,           usedx:0.05 outputto:rotorplaneDN_  orientation:nacdir {outputoptions} noffsets:10\n",
    "nearwake,    rotorplane, 0,       2,      2,    0.7,      1,  11, 11,            usedx:0.05 outputto:nearwake_      orientation:nacdir {outputoptions} noffsets:4\n",
    "turbsw,      streamwise, 4,       10,      0,    0.7,     1.5, 11, 11,           usedx:0.05 outputto:turbsw_        orientation:nacdir {outputoptions} noffsets:0\n",
    "turbhh,      hubheight,  4,       10,      2,       0,    0,   11, 11,           usedx:0.05 outputto:turbhh_        orientation:nacdir {outputoptions} noffsets:0\n",
    "turb027,     hubheight,  4,       10,      2,    0.50,    0,   11, 11,           usedx:0.05 outputto:turb027_       orientation:nacdir {outputoptions} noffsets:0\n",
    "turb153,     hubheight,  4,       10,      2,    -0.50,  0.50, 11, 11,           usedx:0.05 outputto:turb153_       orientation:nacdir {outputoptions} noffsets:0\n",
    "turb216,     hubheight,  4,       10,      2,      -1,    1,   11, 11,           usedx:0.05 outputto:turb216_       orientation:nacdir {outputoptions} noffsets:0\n",
    "sideplane1,  streamwise, 4,       10,      2,    0.7,     1.5, 11, 11,           usedx:0.05 outputto:sideplane1_    orientation:nacdir {outputoptions} noffsets:1\n",
    "sideplane2,  streamwise, 4,       10,     -2,    0.7,     1.5, 11, 11,           usedx:0.05 outputto:sideplane2_    orientation:nacdir {outputoptions} noffsets:1\n",
    "XYdomain027, hubheight,  8,       8,       2,       0,    90,  11, 11, units:meter usedx:10 outputto:XYdomain_027_ orientation:nacdir center:specified centerx:100 centery:100 centerz:27 wholedomain:1  {outputoptions} noffsets:0\n",
    "XYdomain090, hubheight,  8,       8,       2,       0,    90,  11, 11, units:meter usedx:10 outputto:XYdomain_090_ orientation:nacdir center:specified centerx:100 centery:100 centerz:90 wholedomain:1  {outputoptions} noffsets:0\n",
    "XYdomain153, hubheight,  8,       8,       2,       0,    153, 11, 11, units:meter usedx:10 outputto:XYdomain_153_ orientation:nacdir center:specified centerx:100 centery:100 centerz:153 wholedomain:1  {outputoptions} noffsets:0\n",
    "\"\"\".format(outputoptions=outputoptions)\n",
    "\n",
    "case.setAMRWindInput('sampling_csvtextbox', samplingcsv)\n",
    "case.setAMRWindInput('sampling_deleteprev', False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "6cdd4e69-0c54-42fa-a36a-da459e7bc876",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['virtualmast', 'T0_rotorplaneUP', 'T0_rotorplaneDN', 'T0_nearwake', 'T0_turbsw', 'T0_turbhh', 'T0_turb027', 'T0_turb153', 'T0_turb216', 'T0_sideplane1', 'T0_sideplane2', 'Farm_XYdomain027', 'Farm_XYdomain090', 'Farm_XYdomain153']\n"
     ]
    }
   ],
   "source": [
    "case.sampling_createAllProbes(verbose=False)\n",
    "# Print out existing list of turbines\n",
    "print(case.listboxpopupwindict['listboxsampling'].getitemlist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "76214e11-fb16-43fe-8d58-c0e08414ba99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 750x750 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(6,6), facecolor='w', dpi=125)\n",
    "\n",
    "# Set any additional items to plot\n",
    "case.popup_storteddata['plotdomain']['plot_turbines']        = case.listboxpopupwindict['listboxactuator'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_refineboxes']     = [] #case.listboxpopupwindict['listboxtagging'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes']    = ['T0_rotorplaneUP', 'T0_rotorplaneDN', 'T0_turbhh', 'T0_turbsw','T0_nearwake',\n",
    "                                                               'T0_sideplane1', 'T0_sideplane2'] #case.listboxpopupwindict['listboxsampling'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes_style'] = \"{'markersize':.25, 'marker':'.', 'linestyle':'None', 'alpha':0.1}\"\n",
    "case.popup_storteddata['plotdomain']['plot_chooseview']      = 'XY'\n",
    "case.plotDomain(ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f7fb648c-979c-4c36-a4c6-00934a35094d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 750x750 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(6,6), facecolor='w', dpi=125)\n",
    "\n",
    "# Set any additional items to plot\n",
    "case.popup_storteddata['plotdomain']['plot_turbines']        = case.listboxpopupwindict['listboxactuator'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_refineboxes']     = [] #case.listboxpopupwindict['listboxtagging'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes']    = [#'T0_rotorplaneUP', 'T0_rotorplaneDN', 'T0_turbhh', 'T0_turbsw','T0_nearwake',\n",
    "                                                               'T0_turb027', 'T0_turbhh', 'T0_turb153','T0_turb216']\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes_style'] = \"{'markersize':.25, 'marker':'.', 'linestyle':'None', 'alpha':0.1}\"\n",
    "case.popup_storteddata['plotdomain']['plot_chooseview']      = 'XZ'\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes_legend'] = \"{'title':'Sampling probes', 'fontsize':6, 'loc':'upper right', 'markerscale':6}\"\n",
    "case.plotDomain(ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b5acd4ef-17d3-4e1a-bee1-505a174e4804",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1500x750 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(12,6), facecolor='w', dpi=125)\n",
    "\n",
    "# Set any additional items to plot\n",
    "case.popup_storteddata['plotdomain']['plot_turbines']        = case.listboxpopupwindict['listboxactuator'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_refineboxes']     = case.listboxpopupwindict['listboxtagging'].getitemlist()\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes']    = case.listboxpopupwindict['listboxsampling'].getitemlist() #['p_hub']\n",
    "case.popup_storteddata['plotdomain']['plot_sampleprobes_style'] = \"{'markersize':.1, 'marker':'.', 'linestyle':'None', 'alpha':0.1}\"\n",
    "case.popup_storteddata['plotdomain']['plot_chooseview'] = 'XZ'\n",
    "case.plotDomain(ax=ax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1f9f2791-14e0-481e-940e-98e8904107e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Checking inputs --\n",
      "[ PASS] max_level:           max_level = 4 >= 0\n",
      "[ PASS] dt & CFL:            DT and CFL OK\n",
      "[ PASS] restart dir:         Restart directory /pscratch/ndeveld/hfm-2025-q1/abl/chk30000 exists\n",
      "[ PASS] boundary plane dir:  Restart directory /tscratch/lcheung/HFM/exawind-benchmarks/convective_abl/bndry_file exists\n",
      "[ PASS] Actuator physics:    incflo.physics and ICNS.source_terms OK for Actuators\n",
      "[ PASS] Actuator FST:T0      [T0_NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/5MW_Land_DLL_WTurb_cpp.fst] exists\n",
      "[ PASS] Actuator FST:T0      Actuator density=1.000000, matches incflo.density=1.000000\n",
      "[ PASS] Actuator FST:T0      CompInflow OK\n",
      "[ PASS] Actuator FST:T0      [T0_NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/NRELOffshrBsline5MW_Onshore_AeroDyn.dat] exists\n",
      "[ PASS] Actuator FST:T0      WakeMod=0 OK\n",
      "[ PASS] Actuator FST:T0      AirDens=1.000000, matches incflo.density=1.000000\n",
      "[ PASS] Actuator FST:T0      [/projects/wind_uq/lcheung/amrwind-frontend/turbines/OpenFAST_NREL2p8-127_AWAKEN/libdiscon.so] exists\n",
      "[ PASS] Actuator FST:T0      WE_RhoAir=1.000000 in DISCON matches AirDens=1.000000 and incflo.density=1.000000\n",
      "[ PASS] Sampling probes:virtualmast is inside domain\n",
      "[ PASS] Sampling probes:T0_rotorplaneUP \n",
      "[ PASS] Sampling probes:T0_rotorplaneDN \n",
      "[ PASS] Sampling probes:T0_nearwake \n",
      "[ PASS] Sampling probes:T0_turbsw \n",
      "[ PASS] Sampling probes:T0_turbhh \n",
      "[ PASS] Sampling probes:T0_turb027 \n",
      "[ PASS] Sampling probes:T0_turb153 \n",
      "[ PASS] Sampling probes:T0_turb216 \n",
      "[ PASS] Sampling probes:T0_sideplane1 \n",
      "[ PASS] Sampling probes:T0_sideplane2 \n",
      "[ PASS] Sampling probes:Farm_XYdomain027 \n",
      "[ PASS] Sampling probes:Farm_XYdomain090 \n",
      "[ PASS] Sampling probes:Farm_XYdomain153 \n",
      "\n",
      "Results: \n",
      " 27 PASS\n",
      " 0 SKIP\n",
      " 0 FAIL\n",
      " 0 WARN\n"
     ]
    }
   ],
   "source": [
    "case.validate();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ae0a3233-e40f-44e3-a676-5c352163566e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#raise ValueError('Stop')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb2a8278-b1e8-44a2-8f2c-692f17f71853",
   "metadata": {},
   "source": [
    "## Write out the input file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "224831d6-4a06-45c4-92da-c6e453cb9624",
   "metadata": {
    "tags": []
   },
   "source": [
    "### For the w/turbine ALM case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "362e99e8-47f3-4e58-affc-5a66c133b68b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# --- Simulation time control parameters ---\n",
      "time.stop_time                           = 16000.0             # Max (simulated) time to evolve [s]\n",
      "time.max_step                            = -1                  \n",
      "time.fixed_dt                            = 0.01721763085399449 # Fixed timestep size (in seconds). If negative, then time.cfl is used\n",
      "time.checkpoint_interval                 = 10000               \n",
      "time.checkpoint_start                    = 30000               \n",
      "incflo.physics                           = ABL Actuator        # List of physics models to include in simulation.\n",
      "incflo.verbose                           = 0                   \n",
      "io.check_file                            = chk                 \n",
      "io.restart_file                          = /pscratch/ndeveld/hfm-2025-q1/abl/chk30000\n",
      "incflo.use_godunov                       = true                \n",
      "incflo.godunov_type                      = weno_z              \n",
      "turbulence.model                         = OneEqKsgsM84        \n",
      "TKE.source_terms                         = KsgsM84Src          \n",
      "nodal_proj.mg_rtol                       = 1e-08               \n",
      "nodal_proj.mg_atol                       = 1e-08               \n",
      "mac_proj.mg_rtol                         = 1e-08               \n",
      "mac_proj.mg_atol                         = 1e-08               \n",
      "diffusion.mg_rtol                        = 1e-08               \n",
      "diffusion.mg_atol                        = 1e-08               \n",
      "temperature_diffusion.mg_rtol            = 1e-08               \n",
      "temperature_diffusion.mg_atol            = 1e-08               \n",
      "incflo.gravity                           = 0.0 0.0 -9.81       # Gravitational acceleration vector (x,y,z) [m/s^2]\n",
      "incflo.density                           = 1.0                 # Fluid density [kg/m^3]\n",
      "transport.viscosity                      = 0.0                 # Fluid dynamic viscosity [kg/m-s]\n",
      "transport.laminar_prandtl                = 0.7                 # Laminar prandtl number\n",
      "transport.turbulent_prandtl              = 0.3333              # Turbulent prandtl number\n",
      "\n",
      "# --- Geometry and Mesh ---\n",
      "geometry.prob_lo                         = 0.0 0.0 0.0         \n",
      "geometry.prob_hi                         = 5120.0 5120.0 1920.0\n",
      "amr.n_cell                               = 512 512 192         # Number of cells in x, y, and z directions\n",
      "amr.max_level                            = 2                   \n",
      "geometry.is_periodic                     = 0 0 0               \n",
      "xlo.type                                 = mass_inflow         \n",
      "xlo.density                              = 1.0                 \n",
      "xlo.temperature                          = 0.0                 \n",
      "xlo.tke                                  = 0.0                 \n",
      "xhi.type                                 = pressure_outflow    \n",
      "ylo.type                                 = mass_inflow         \n",
      "ylo.density                              = 1.0                 \n",
      "ylo.temperature                          = 0.0                 \n",
      "ylo.tke                                  = 0.0                 \n",
      "yhi.type                                 = pressure_outflow    \n",
      "zlo.type                                 = wall_model          \n",
      "zlo.temperature_type                     = wall_model          \n",
      "zlo.tke_type                             = zero_gradient       \n",
      "zhi.type                                 = slip_wall           \n",
      "zhi.temperature_type                     = fixed_gradient      \n",
      "zhi.temperature                          = 0.003               \n",
      "\n",
      "# --- ABL parameters ---\n",
      "ICNS.source_terms                        = BoussinesqBuoyancy CoriolisForcing ActuatorForcing BodyForce ABLMeanBoussinesq\n",
      "ABL.stats_output_frequency               = 1                   \n",
      "ABL.stats_output_format                  = netcdf              \n",
      "ABL.tendency_forcing                     = false               \n",
      "ABL.bndry_io_mode                        = 1                   \n",
      "ABL.bndry_file                           = /tscratch/lcheung/HFM/exawind-benchmarks/convective_abl/bndry_file\n",
      "ABL.bndry_planes                         = xlo ylo             \n",
      "ABL.bndry_output_start_time              = 15000.0             \n",
      "ABL.bndry_var_names                      = velocity temperature tke\n",
      "ABL.bndry_output_format                  = native              \n",
      "incflo.velocity                          = 9.8726896031426 5.7 0.0\n",
      "ABLForcing.abl_forcing_height            = 90.0                \n",
      "ABL.kappa                                = 0.41                \n",
      "ABL.normal_direction                     = 2                   \n",
      "ABL.surface_roughness_z0                 = 0.01                \n",
      "ABL.reference_temperature                = 300.0               \n",
      "ABL.surface_temp_rate                    = 0.0                 \n",
      "ABL.surface_temp_flux                    = 0.005               # Surface temperature flux [K-m/s]\n",
      "ABL.log_law_height                       = 5.0                 \n",
      "ABL.wall_shear_stress_type               = local               \n",
      "ABL.wf_velocity                          = 6.0977889026612075 3.6097639593035185\n",
      "ABL.wf_vmag                              = 7.103916682319445   \n",
      "ABL.wf_theta                             = 300.20261481689676  \n",
      "CoriolisForcing.latitude                 = 40.0                \n",
      "CoriolisForcing.rotational_time_period   = 86400.0             \n",
      "CoriolisForcing.north_vector             = 0.0 1.0 0.0         \n",
      "CoriolisForcing.east_vector              = 1.0 0.0 0.0         \n",
      "BoussinesqBuoyancy.reference_temperature = 300.0               \n",
      "BodyForce.magnitude                      = -0.0002743665569299508 0.0011708563286373845 0.0\n",
      "ABL.temperature_heights                  = 0.0 750.0 850.0 2000.0\n",
      "ABL.temperature_values                   = 300.0 300.0 308.0 311.45\n",
      "ABLMeanBoussinesq.read_temperature_profile = true                \n",
      "ABLMeanBoussinesq.temperature_profile_filename = avg_theta.dat       \n",
      "ABL.perturb_velocity                     = true                \n",
      "ABL.perturb_ref_height                   = 50.0                \n",
      "ABL.Uperiods                             = 4.0                 \n",
      "ABL.Vperiods                             = 4.0                 \n",
      "ABL.deltaU                               = 1.0                 \n",
      "ABL.deltaV                               = 1.0                 \n",
      "ABL.perturb_temperature                  = true                \n",
      "ABL.theta_amplitude                      = 0.8                 \n",
      "ABL.cutoff_height                        = 50.0                \n",
      "time.plot_interval                       = 10000               \n",
      "io.plot_file                             = plt                 \n",
      "\n",
      "#---- tagging defs ----\n",
      "tagging.labels                           = T0_level_0_zone T0_level_1_zone T0_level_2_zone T0_level_3_zone\n",
      "tagging.T0_level_0_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_0_zone.shapes           = T0_level_0_zone     \n",
      "tagging.T0_level_0_zone.level            = 0                   \n",
      "tagging.T0_level_0_zone.T0_level_0_zone.type = box                 \n",
      "tagging.T0_level_0_zone.T0_level_0_zone.origin = 1569.4039956158035 939.4039956158036 -4.5\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.xaxis = 1636.788013152589 944.9999999999998 0.0\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.yaxis = -629.9999999999999 1091.1920087683927 -0.0\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.zaxis = 0.0 0.0 346.5       \n",
      "tagging.T0_level_1_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_1_zone.shapes           = T0_level_1_zone     \n",
      "tagging.T0_level_1_zone.level            = 1                   \n",
      "tagging.T0_level_1_zone.T0_level_1_zone.type = box                 \n",
      "tagging.T0_level_1_zone.T0_level_1_zone.origin = 1653.2019978079018 1424.2615982463215 -4.5\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.xaxis = 818.3940065762945 472.4999999999999 0.0\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.yaxis = -251.99999999999994 436.47680350735703 -0.0\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.zaxis = 0.0 0.0 283.5       \n",
      "tagging.T0_level_2_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_2_zone.shapes           = T0_level_2_zone     \n",
      "tagging.T0_level_2_zone.level            = 2                   \n",
      "tagging.T0_level_2_zone.T0_level_2_zone.type = box                 \n",
      "tagging.T0_level_2_zone.T0_level_2_zone.origin = 1742.350998903951 1584.850998903951 -4.5\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.xaxis = 354.6374028497276 204.74999999999994 0.0\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.yaxis = -157.49999999999997 272.7980021920982 -0.0\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.zaxis = 0.0 0.0 220.5       \n",
      "tagging.T0_level_3_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_3_zone.shapes           = T0_level_3_zone     \n",
      "tagging.T0_level_3_zone.level            = 3                   \n",
      "tagging.T0_level_3_zone.T0_level_3_zone.type = box                 \n",
      "tagging.T0_level_3_zone.T0_level_3_zone.origin = 1781.1605993423705 1643.6307991231608 -4.5\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.xaxis = 163.6788013152589 94.49999999999999 0.0\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.yaxis = -125.99999999999997 218.23840175367852 -0.0\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.zaxis = 0.0 0.0 189.0       \n",
      "\n",
      "#---- actuator defs ----\n",
      "Actuator.labels                          = T0                  \n",
      "Actuator.T0.type                         = TurbineFastLine     \n",
      "Actuator.T0.openfast_input_file          = T0_NREL5MW_v402_ROSCO/openfast-cpp/5MW_Land_DLL_WTurb_cpp/5MW_Land_DLL_WTurb_cpp.fst\n",
      "Actuator.T0.base_position                = 1800.0 1800.0 0.0   \n",
      "Actuator.T0.rotor_diameter               = 126.0               \n",
      "Actuator.T0.hub_height                   = 90.0                \n",
      "Actuator.T0.num_points_blade             = 25                  \n",
      "Actuator.T0.num_points_tower             = 11                  \n",
      "Actuator.T0.epsilon                      = 2.0 2.0 2.0         \n",
      "Actuator.T0.epsilon_tower                = 2.0 2.0 2.0         \n",
      "Actuator.T0.openfast_start_time          = 0.0                 \n",
      "Actuator.T0.openfast_stop_time           = 3000.0              \n",
      "Actuator.T0.fllc                         = false               \n",
      "Actuator.T0.nacelle_drag_coeff           = 0.0                 \n",
      "Actuator.T0.nacelle_area                 = 0.0                 \n",
      "Actuator.T0.yaw                          = 240.0               \n",
      "Actuator.T0.output_frequency             = 10                  \n",
      "Actuator.T0.density                      = 1.0                 \n",
      "Actuator.T0.num_blades                   = 3                   \n",
      "Actuator.T0.use_tip_correction           = true                \n",
      "Actuator.T0.use_root_correction          = true                \n",
      "\n",
      "#---- postprocessing defs ----\n",
      "incflo.post_processing                   = metmast_ rotorplaneUP_ rotorplaneDN_ nearwake_ turbsw_ turbhh_ turb027_ turb153_ turb216_ sideplane1_ sideplane2_ XYdomain_027_ XYdomain_090_ XYdomain_153_\n",
      "metmast_.type                            = Sampling            \n",
      "metmast_.output_frequency                = 1                   \n",
      "metmast_.fields                          = velocity temperature tke\n",
      "rotorplaneUP_.type                       = Sampling            \n",
      "rotorplaneUP_.output_frequency           = 50                  \n",
      "rotorplaneUP_.fields                     = velocity temperature tke\n",
      "rotorplaneDN_.type                       = Sampling            \n",
      "rotorplaneDN_.output_frequency           = 50                  \n",
      "rotorplaneDN_.fields                     = velocity temperature tke\n",
      "nearwake_.type                           = Sampling            \n",
      "nearwake_.output_frequency               = 50                  \n",
      "nearwake_.fields                         = velocity temperature tke\n",
      "turbsw_.type                             = Sampling            \n",
      "turbsw_.output_frequency                 = 50                  \n",
      "turbsw_.fields                           = velocity temperature tke\n",
      "turbhh_.type                             = Sampling            \n",
      "turbhh_.output_frequency                 = 50                  \n",
      "turbhh_.fields                           = velocity temperature tke\n",
      "turb027_.type                            = Sampling            \n",
      "turb027_.output_frequency                = 50                  \n",
      "turb027_.fields                          = velocity temperature tke\n",
      "turb153_.type                            = Sampling            \n",
      "turb153_.output_frequency                = 50                  \n",
      "turb153_.fields                          = velocity temperature tke\n",
      "turb216_.type                            = Sampling            \n",
      "turb216_.output_frequency                = 50                  \n",
      "turb216_.fields                          = velocity temperature tke\n",
      "sideplane1_.type                         = Sampling            \n",
      "sideplane1_.output_frequency             = 50                  \n",
      "sideplane1_.fields                       = velocity temperature tke\n",
      "sideplane2_.type                         = Sampling            \n",
      "sideplane2_.output_frequency             = 50                  \n",
      "sideplane2_.fields                       = velocity temperature tke\n",
      "XYdomain_027_.type                       = Sampling            \n",
      "XYdomain_027_.output_frequency           = 50                  \n",
      "XYdomain_027_.fields                     = velocity temperature tke\n",
      "XYdomain_090_.type                       = Sampling            \n",
      "XYdomain_090_.output_frequency           = 50                  \n",
      "XYdomain_090_.fields                     = velocity temperature tke\n",
      "XYdomain_153_.type                       = Sampling            \n",
      "XYdomain_153_.output_frequency           = 50                  \n",
      "XYdomain_153_.fields                     = velocity temperature tke\n",
      "\n",
      "#---- sample defs ----\n",
      "metmast_.labels                          = virtualmast         \n",
      "rotorplaneUP_.labels                     = T0_rotorplaneUP     \n",
      "rotorplaneDN_.labels                     = T0_rotorplaneDN     \n",
      "nearwake_.labels                         = T0_nearwake         \n",
      "turbsw_.labels                           = T0_turbsw           \n",
      "turbhh_.labels                           = T0_turbhh           \n",
      "turb027_.labels                          = T0_turb027          \n",
      "turb153_.labels                          = T0_turb153          \n",
      "turb216_.labels                          = T0_turb216          \n",
      "sideplane1_.labels                       = T0_sideplane1       \n",
      "sideplane2_.labels                       = T0_sideplane2       \n",
      "XYdomain_027_.labels                     = Farm_XYdomain027    \n",
      "XYdomain_090_.labels                     = Farm_XYdomain090    \n",
      "XYdomain_153_.labels                     = Farm_XYdomain153    \n",
      "metmast_.virtualmast.type                = LineSampler         \n",
      "metmast_.virtualmast.num_points          = 20                  \n",
      "metmast_.virtualmast.start               = 1800.0 1800.0 10.0  \n",
      "metmast_.virtualmast.end                 = 1800.0 1800.0 200.0 \n",
      "rotorplaneUP_.T0_rotorplaneUP.type       = PlaneSampler        \n",
      "rotorplaneUP_.T0_rotorplaneUP.num_points = 81 35               \n",
      "rotorplaneUP_.T0_rotorplaneUP.origin     = 1489.523196492643 1329.7615982463215 1.8000000000000114\n",
      "rotorplaneUP_.T0_rotorplaneUP.axis1      = -251.99999999999994 436.47680350735703 -0.0\n",
      "rotorplaneUP_.T0_rotorplaneUP.axis2      = 0.0 0.0 214.2       \n",
      "rotorplaneUP_.T0_rotorplaneUP.offset_vector = 0.8660254037844386 0.4999999999999999 0.0\n",
      "rotorplaneUP_.T0_rotorplaneUP.offsets    = 0.0 126.0 252.0 378.0 504.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.type       = PlaneSampler        \n",
      "rotorplaneDN_.T0_rotorplaneDN.num_points = 81 35               \n",
      "rotorplaneDN_.T0_rotorplaneDN.origin     = 1926.0 1581.7615982463215 1.8000000000000114\n",
      "rotorplaneDN_.T0_rotorplaneDN.axis1      = -251.99999999999994 436.47680350735703 -0.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.axis2      = 0.0 0.0 214.2       \n",
      "rotorplaneDN_.T0_rotorplaneDN.offset_vector = 0.8660254037844386 0.4999999999999999 0.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.offsets    = 0.0 126.0 252.0 378.0 504.0 630.0 756.0 882.0 1008.0 1134.0 1260.0\n",
      "nearwake_.T0_nearwake.type               = PlaneSampler        \n",
      "nearwake_.T0_nearwake.num_points         = 81 35               \n",
      "nearwake_.T0_nearwake.origin             = 1926.0 1581.7615982463215 1.8000000000000114\n",
      "nearwake_.T0_nearwake.axis1              = -251.99999999999994 436.47680350735703 -0.0\n",
      "nearwake_.T0_nearwake.axis2              = 0.0 0.0 214.2       \n",
      "nearwake_.T0_nearwake.offset_vector      = 0.8660254037844386 0.4999999999999999 0.0\n",
      "nearwake_.T0_nearwake.offsets            = 0.0 63.0 126.0 189.0 252.0\n",
      "turbsw_.T0_turbsw.type                   = PlaneSampler        \n",
      "turbsw_.T0_turbsw.num_points             = 281 45              \n",
      "turbsw_.T0_turbsw.origin                 = 1363.523196492643 1548.0 1.8000000000000114\n",
      "turbsw_.T0_turbsw.axis1                  = 1527.6688122757496 881.9999999999998 0.0\n",
      "turbsw_.T0_turbsw.axis2                  = 0.0 0.0 277.2       \n",
      "turbsw_.T0_turbsw.offset_vector          = 0.0 0.0 0.0         \n",
      "turbhh_.T0_turbhh.type                   = PlaneSampler        \n",
      "turbhh_.T0_turbhh.num_points             = 281 81              \n",
      "turbhh_.T0_turbhh.origin                 = 1489.523196492643 1329.7615982463215 90.0\n",
      "turbhh_.T0_turbhh.axis1                  = 1527.6688122757496 881.9999999999998 0.0\n",
      "turbhh_.T0_turbhh.axis2                  = -251.99999999999994 436.47680350735703 -0.0\n",
      "turbhh_.T0_turbhh.offset_vector          = 0.0 0.0 0.0         \n",
      "turb027_.T0_turb027.type                 = PlaneSampler        \n",
      "turb027_.T0_turb027.num_points           = 281 81              \n",
      "turb027_.T0_turb027.origin               = 1489.523196492643 1329.7615982463215 27.0\n",
      "turb027_.T0_turb027.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb027_.T0_turb027.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb027_.T0_turb027.offset_vector        = 0.0 0.0 0.0         \n",
      "turb153_.T0_turb153.type                 = PlaneSampler        \n",
      "turb153_.T0_turb153.num_points           = 281 81              \n",
      "turb153_.T0_turb153.origin               = 1489.523196492643 1329.7615982463215 153.0\n",
      "turb153_.T0_turb153.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb153_.T0_turb153.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb153_.T0_turb153.offset_vector        = 0.0 0.0 0.0         \n",
      "turb216_.T0_turb216.type                 = PlaneSampler        \n",
      "turb216_.T0_turb216.num_points           = 281 81              \n",
      "turb216_.T0_turb216.origin               = 1489.523196492643 1329.7615982463215 216.0\n",
      "turb216_.T0_turb216.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb216_.T0_turb216.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb216_.T0_turb216.offset_vector        = 0.0 0.0 0.0         \n",
      "sideplane1_.T0_sideplane1.type           = PlaneSampler        \n",
      "sideplane1_.T0_sideplane1.num_points     = 281 45              \n",
      "sideplane1_.T0_sideplane1.origin         = 1363.523196492643 1548.0 1.8000000000000114\n",
      "sideplane1_.T0_sideplane1.axis1          = 1527.6688122757496 881.9999999999998 0.0\n",
      "sideplane1_.T0_sideplane1.axis2          = 0.0 0.0 277.2       \n",
      "sideplane1_.T0_sideplane1.offset_vector  = -0.4999999999999999 0.8660254037844386 -0.0\n",
      "sideplane1_.T0_sideplane1.offsets        = 0.0 252.0           \n",
      "sideplane2_.T0_sideplane2.type           = PlaneSampler        \n",
      "sideplane2_.T0_sideplane2.num_points     = 281 45              \n",
      "sideplane2_.T0_sideplane2.origin         = 1363.523196492643 1548.0 1.8000000000000114\n",
      "sideplane2_.T0_sideplane2.axis1          = 1527.6688122757496 881.9999999999998 0.0\n",
      "sideplane2_.T0_sideplane2.axis2          = 0.0 0.0 277.2       \n",
      "sideplane2_.T0_sideplane2.offset_vector  = -0.4999999999999999 0.8660254037844386 -0.0\n",
      "sideplane2_.T0_sideplane2.offsets        = 0.0 -252.0          \n",
      "XYdomain_027_.Farm_XYdomain027.type      = PlaneSampler        \n",
      "XYdomain_027_.Farm_XYdomain027.num_points = 513 513             \n",
      "XYdomain_027_.Farm_XYdomain027.origin    = 0.0001 0.0001 27.0  \n",
      "XYdomain_027_.Farm_XYdomain027.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_027_.Farm_XYdomain027.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_027_.Farm_XYdomain027.offset_vector = 0.0 0.0 0.0         \n",
      "XYdomain_090_.Farm_XYdomain090.type      = PlaneSampler        \n",
      "XYdomain_090_.Farm_XYdomain090.num_points = 513 513             \n",
      "XYdomain_090_.Farm_XYdomain090.origin    = 0.0001 0.0001 90.0  \n",
      "XYdomain_090_.Farm_XYdomain090.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_090_.Farm_XYdomain090.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_090_.Farm_XYdomain090.offset_vector = 0.0 0.0 0.0         \n",
      "XYdomain_153_.Farm_XYdomain153.type      = PlaneSampler        \n",
      "XYdomain_153_.Farm_XYdomain153.num_points = 513 513             \n",
      "XYdomain_153_.Farm_XYdomain153.origin    = 0.0001 0.0001 153.0 \n",
      "XYdomain_153_.Farm_XYdomain153.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_153_.Farm_XYdomain153.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_153_.Farm_XYdomain153.offset_vector = 0.0 0.0 0.0         \n",
      "\n",
      "#---- extra params ----\n",
      "io.KE_int                                = -1                  \n",
      "io.line_plot_int                         = 1                   \n",
      "CoriolisForcing.turn_off_vertical_force  = True                \n",
      "#== END AMR-WIND INPUT ==\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# For the w/turbine ALM case\n",
    "case.setAMRWindInput('amr.max_level',  2)\n",
    "print(case.writeAMRWindInput(outputfile))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3cd88dd-f19e-4d29-91e8-b171e591d72b",
   "metadata": {
    "tags": []
   },
   "source": [
    "### For the without turbine ALM case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0e92cc58-d913-49a6-a804-ecb472e73d62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# --- Simulation time control parameters ---\n",
      "time.stop_time                           = 16000.0             # Max (simulated) time to evolve [s]\n",
      "time.max_step                            = -1                  \n",
      "time.fixed_dt                            = 0.01721763085399449 # Fixed timestep size (in seconds). If negative, then time.cfl is used\n",
      "time.checkpoint_interval                 = 10000               \n",
      "time.checkpoint_start                    = 30000               \n",
      "incflo.physics                           = ABL                 # List of physics models to include in simulation.\n",
      "incflo.verbose                           = 0                   \n",
      "io.check_file                            = chk                 \n",
      "io.restart_file                          = /pscratch/ndeveld/hfm-2025-q1/abl/chk30000\n",
      "incflo.use_godunov                       = true                \n",
      "incflo.godunov_type                      = weno_z              \n",
      "turbulence.model                         = OneEqKsgsM84        \n",
      "TKE.source_terms                         = KsgsM84Src          \n",
      "nodal_proj.mg_rtol                       = 1e-08               \n",
      "nodal_proj.mg_atol                       = 1e-08               \n",
      "mac_proj.mg_rtol                         = 1e-08               \n",
      "mac_proj.mg_atol                         = 1e-08               \n",
      "diffusion.mg_rtol                        = 1e-08               \n",
      "diffusion.mg_atol                        = 1e-08               \n",
      "temperature_diffusion.mg_rtol            = 1e-08               \n",
      "temperature_diffusion.mg_atol            = 1e-08               \n",
      "incflo.gravity                           = 0.0 0.0 -9.81       # Gravitational acceleration vector (x,y,z) [m/s^2]\n",
      "incflo.density                           = 1.0                 # Fluid density [kg/m^3]\n",
      "transport.viscosity                      = 0.0                 # Fluid dynamic viscosity [kg/m-s]\n",
      "transport.laminar_prandtl                = 0.7                 # Laminar prandtl number\n",
      "transport.turbulent_prandtl              = 0.3333              # Turbulent prandtl number\n",
      "\n",
      "# --- Geometry and Mesh ---\n",
      "geometry.prob_lo                         = 0.0 0.0 0.0         \n",
      "geometry.prob_hi                         = 5120.0 5120.0 1920.0\n",
      "amr.n_cell                               = 512 512 192         # Number of cells in x, y, and z directions\n",
      "amr.max_level                            = 2                   \n",
      "geometry.is_periodic                     = 0 0 0               \n",
      "xlo.type                                 = mass_inflow         \n",
      "xlo.density                              = 1.0                 \n",
      "xlo.temperature                          = 0.0                 \n",
      "xlo.tke                                  = 0.0                 \n",
      "xhi.type                                 = pressure_outflow    \n",
      "ylo.type                                 = mass_inflow         \n",
      "ylo.density                              = 1.0                 \n",
      "ylo.temperature                          = 0.0                 \n",
      "ylo.tke                                  = 0.0                 \n",
      "yhi.type                                 = pressure_outflow    \n",
      "zlo.type                                 = wall_model          \n",
      "zlo.temperature_type                     = wall_model          \n",
      "zlo.tke_type                             = zero_gradient       \n",
      "zhi.type                                 = slip_wall           \n",
      "zhi.temperature_type                     = fixed_gradient      \n",
      "zhi.temperature                          = 0.003               \n",
      "\n",
      "# --- ABL parameters ---\n",
      "ICNS.source_terms                        = BoussinesqBuoyancy CoriolisForcing BodyForce ABLMeanBoussinesq\n",
      "ABL.stats_output_frequency               = 1                   \n",
      "ABL.stats_output_format                  = netcdf              \n",
      "ABL.tendency_forcing                     = false               \n",
      "ABL.bndry_io_mode                        = 1                   \n",
      "ABL.bndry_file                           = /tscratch/lcheung/HFM/exawind-benchmarks/convective_abl/bndry_file\n",
      "ABL.bndry_planes                         = xlo ylo             \n",
      "ABL.bndry_output_start_time              = 15000.0             \n",
      "ABL.bndry_var_names                      = velocity temperature tke\n",
      "ABL.bndry_output_format                  = native              \n",
      "incflo.velocity                          = 9.8726896031426 5.7 0.0\n",
      "ABLForcing.abl_forcing_height            = 90.0                \n",
      "ABL.kappa                                = 0.41                \n",
      "ABL.normal_direction                     = 2                   \n",
      "ABL.surface_roughness_z0                 = 0.01                \n",
      "ABL.reference_temperature                = 300.0               \n",
      "ABL.surface_temp_rate                    = 0.0                 \n",
      "ABL.surface_temp_flux                    = 0.005               # Surface temperature flux [K-m/s]\n",
      "ABL.log_law_height                       = 5.0                 \n",
      "ABL.wall_shear_stress_type               = local               \n",
      "ABL.wf_velocity                          = 6.0977889026612075 3.6097639593035185\n",
      "ABL.wf_vmag                              = 7.103916682319445   \n",
      "ABL.wf_theta                             = 300.20261481689676  \n",
      "CoriolisForcing.latitude                 = 40.0                \n",
      "CoriolisForcing.rotational_time_period   = 86400.0             \n",
      "CoriolisForcing.north_vector             = 0.0 1.0 0.0         \n",
      "CoriolisForcing.east_vector              = 1.0 0.0 0.0         \n",
      "BoussinesqBuoyancy.reference_temperature = 300.0               \n",
      "BodyForce.magnitude                      = -0.0002743665569299508 0.0011708563286373845 0.0\n",
      "ABL.temperature_heights                  = 0.0 750.0 850.0 2000.0\n",
      "ABL.temperature_values                   = 300.0 300.0 308.0 311.45\n",
      "ABLMeanBoussinesq.read_temperature_profile = true                \n",
      "ABLMeanBoussinesq.temperature_profile_filename = avg_theta.dat       \n",
      "ABL.perturb_velocity                     = true                \n",
      "ABL.perturb_ref_height                   = 50.0                \n",
      "ABL.Uperiods                             = 4.0                 \n",
      "ABL.Vperiods                             = 4.0                 \n",
      "ABL.deltaU                               = 1.0                 \n",
      "ABL.deltaV                               = 1.0                 \n",
      "ABL.perturb_temperature                  = true                \n",
      "ABL.theta_amplitude                      = 0.8                 \n",
      "ABL.cutoff_height                        = 50.0                \n",
      "time.plot_interval                       = 10000               \n",
      "io.plot_file                             = plt                 \n",
      "\n",
      "#---- tagging defs ----\n",
      "tagging.labels                           = T0_level_0_zone T0_level_1_zone T0_level_2_zone T0_level_3_zone\n",
      "tagging.T0_level_0_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_0_zone.shapes           = T0_level_0_zone     \n",
      "tagging.T0_level_0_zone.level            = 0                   \n",
      "tagging.T0_level_0_zone.T0_level_0_zone.type = box                 \n",
      "tagging.T0_level_0_zone.T0_level_0_zone.origin = 1569.4039956158035 939.4039956158036 -4.5\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.xaxis = 1636.788013152589 944.9999999999998 0.0\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.yaxis = -629.9999999999999 1091.1920087683927 -0.0\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.zaxis = 0.0 0.0 346.5       \n",
      "tagging.T0_level_1_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_1_zone.shapes           = T0_level_1_zone     \n",
      "tagging.T0_level_1_zone.level            = 1                   \n",
      "tagging.T0_level_1_zone.T0_level_1_zone.type = box                 \n",
      "tagging.T0_level_1_zone.T0_level_1_zone.origin = 1653.2019978079018 1424.2615982463215 -4.5\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.xaxis = 818.3940065762945 472.4999999999999 0.0\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.yaxis = -251.99999999999994 436.47680350735703 -0.0\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.zaxis = 0.0 0.0 283.5       \n",
      "tagging.T0_level_2_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_2_zone.shapes           = T0_level_2_zone     \n",
      "tagging.T0_level_2_zone.level            = 2                   \n",
      "tagging.T0_level_2_zone.T0_level_2_zone.type = box                 \n",
      "tagging.T0_level_2_zone.T0_level_2_zone.origin = 1742.350998903951 1584.850998903951 -4.5\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.xaxis = 354.6374028497276 204.74999999999994 0.0\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.yaxis = -157.49999999999997 272.7980021920982 -0.0\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.zaxis = 0.0 0.0 220.5       \n",
      "tagging.T0_level_3_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_3_zone.shapes           = T0_level_3_zone     \n",
      "tagging.T0_level_3_zone.level            = 3                   \n",
      "tagging.T0_level_3_zone.T0_level_3_zone.type = box                 \n",
      "tagging.T0_level_3_zone.T0_level_3_zone.origin = 1781.1605993423705 1643.6307991231608 -4.5\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.xaxis = 163.6788013152589 94.49999999999999 0.0\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.yaxis = -125.99999999999997 218.23840175367852 -0.0\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.zaxis = 0.0 0.0 189.0       \n",
      "\n",
      "#---- postprocessing defs ----\n",
      "incflo.post_processing                   = metmast_ rotorplaneUP_ rotorplaneDN_ nearwake_ turbsw_ turbhh_ turb027_ turb153_ turb216_ sideplane1_ sideplane2_ XYdomain_027_ XYdomain_090_ XYdomain_153_\n",
      "metmast_.type                            = Sampling            \n",
      "metmast_.output_frequency                = 1                   \n",
      "metmast_.fields                          = velocity temperature tke\n",
      "rotorplaneUP_.type                       = Sampling            \n",
      "rotorplaneUP_.output_frequency           = 50                  \n",
      "rotorplaneUP_.fields                     = velocity temperature tke\n",
      "rotorplaneDN_.type                       = Sampling            \n",
      "rotorplaneDN_.output_frequency           = 50                  \n",
      "rotorplaneDN_.fields                     = velocity temperature tke\n",
      "nearwake_.type                           = Sampling            \n",
      "nearwake_.output_frequency               = 50                  \n",
      "nearwake_.fields                         = velocity temperature tke\n",
      "turbsw_.type                             = Sampling            \n",
      "turbsw_.output_frequency                 = 50                  \n",
      "turbsw_.fields                           = velocity temperature tke\n",
      "turbhh_.type                             = Sampling            \n",
      "turbhh_.output_frequency                 = 50                  \n",
      "turbhh_.fields                           = velocity temperature tke\n",
      "turb027_.type                            = Sampling            \n",
      "turb027_.output_frequency                = 50                  \n",
      "turb027_.fields                          = velocity temperature tke\n",
      "turb153_.type                            = Sampling            \n",
      "turb153_.output_frequency                = 50                  \n",
      "turb153_.fields                          = velocity temperature tke\n",
      "turb216_.type                            = Sampling            \n",
      "turb216_.output_frequency                = 50                  \n",
      "turb216_.fields                          = velocity temperature tke\n",
      "sideplane1_.type                         = Sampling            \n",
      "sideplane1_.output_frequency             = 50                  \n",
      "sideplane1_.fields                       = velocity temperature tke\n",
      "sideplane2_.type                         = Sampling            \n",
      "sideplane2_.output_frequency             = 50                  \n",
      "sideplane2_.fields                       = velocity temperature tke\n",
      "XYdomain_027_.type                       = Sampling            \n",
      "XYdomain_027_.output_frequency           = 50                  \n",
      "XYdomain_027_.fields                     = velocity temperature tke\n",
      "XYdomain_090_.type                       = Sampling            \n",
      "XYdomain_090_.output_frequency           = 50                  \n",
      "XYdomain_090_.fields                     = velocity temperature tke\n",
      "XYdomain_153_.type                       = Sampling            \n",
      "XYdomain_153_.output_frequency           = 50                  \n",
      "XYdomain_153_.fields                     = velocity temperature tke\n",
      "\n",
      "#---- sample defs ----\n",
      "metmast_.labels                          = virtualmast         \n",
      "rotorplaneUP_.labels                     = T0_rotorplaneUP     \n",
      "rotorplaneDN_.labels                     = T0_rotorplaneDN     \n",
      "nearwake_.labels                         = T0_nearwake         \n",
      "turbsw_.labels                           = T0_turbsw           \n",
      "turbhh_.labels                           = T0_turbhh           \n",
      "turb027_.labels                          = T0_turb027          \n",
      "turb153_.labels                          = T0_turb153          \n",
      "turb216_.labels                          = T0_turb216          \n",
      "sideplane1_.labels                       = T0_sideplane1       \n",
      "sideplane2_.labels                       = T0_sideplane2       \n",
      "XYdomain_027_.labels                     = Farm_XYdomain027    \n",
      "XYdomain_090_.labels                     = Farm_XYdomain090    \n",
      "XYdomain_153_.labels                     = Farm_XYdomain153    \n",
      "metmast_.virtualmast.type                = LineSampler         \n",
      "metmast_.virtualmast.num_points          = 20                  \n",
      "metmast_.virtualmast.start               = 1800.0 1800.0 10.0  \n",
      "metmast_.virtualmast.end                 = 1800.0 1800.0 200.0 \n",
      "rotorplaneUP_.T0_rotorplaneUP.type       = PlaneSampler        \n",
      "rotorplaneUP_.T0_rotorplaneUP.num_points = 81 35               \n",
      "rotorplaneUP_.T0_rotorplaneUP.origin     = 1489.523196492643 1329.7615982463215 1.8000000000000114\n",
      "rotorplaneUP_.T0_rotorplaneUP.axis1      = -251.99999999999994 436.47680350735703 -0.0\n",
      "rotorplaneUP_.T0_rotorplaneUP.axis2      = 0.0 0.0 214.2       \n",
      "rotorplaneUP_.T0_rotorplaneUP.offset_vector = 0.8660254037844386 0.4999999999999999 0.0\n",
      "rotorplaneUP_.T0_rotorplaneUP.offsets    = 0.0 126.0 252.0 378.0 504.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.type       = PlaneSampler        \n",
      "rotorplaneDN_.T0_rotorplaneDN.num_points = 81 35               \n",
      "rotorplaneDN_.T0_rotorplaneDN.origin     = 1926.0 1581.7615982463215 1.8000000000000114\n",
      "rotorplaneDN_.T0_rotorplaneDN.axis1      = -251.99999999999994 436.47680350735703 -0.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.axis2      = 0.0 0.0 214.2       \n",
      "rotorplaneDN_.T0_rotorplaneDN.offset_vector = 0.8660254037844386 0.4999999999999999 0.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.offsets    = 0.0 126.0 252.0 378.0 504.0 630.0 756.0 882.0 1008.0 1134.0 1260.0\n",
      "nearwake_.T0_nearwake.type               = PlaneSampler        \n",
      "nearwake_.T0_nearwake.num_points         = 81 35               \n",
      "nearwake_.T0_nearwake.origin             = 1926.0 1581.7615982463215 1.8000000000000114\n",
      "nearwake_.T0_nearwake.axis1              = -251.99999999999994 436.47680350735703 -0.0\n",
      "nearwake_.T0_nearwake.axis2              = 0.0 0.0 214.2       \n",
      "nearwake_.T0_nearwake.offset_vector      = 0.8660254037844386 0.4999999999999999 0.0\n",
      "nearwake_.T0_nearwake.offsets            = 0.0 63.0 126.0 189.0 252.0\n",
      "turbsw_.T0_turbsw.type                   = PlaneSampler        \n",
      "turbsw_.T0_turbsw.num_points             = 281 45              \n",
      "turbsw_.T0_turbsw.origin                 = 1363.523196492643 1548.0 1.8000000000000114\n",
      "turbsw_.T0_turbsw.axis1                  = 1527.6688122757496 881.9999999999998 0.0\n",
      "turbsw_.T0_turbsw.axis2                  = 0.0 0.0 277.2       \n",
      "turbsw_.T0_turbsw.offset_vector          = 0.0 0.0 0.0         \n",
      "turbhh_.T0_turbhh.type                   = PlaneSampler        \n",
      "turbhh_.T0_turbhh.num_points             = 281 81              \n",
      "turbhh_.T0_turbhh.origin                 = 1489.523196492643 1329.7615982463215 90.0\n",
      "turbhh_.T0_turbhh.axis1                  = 1527.6688122757496 881.9999999999998 0.0\n",
      "turbhh_.T0_turbhh.axis2                  = -251.99999999999994 436.47680350735703 -0.0\n",
      "turbhh_.T0_turbhh.offset_vector          = 0.0 0.0 0.0         \n",
      "turb027_.T0_turb027.type                 = PlaneSampler        \n",
      "turb027_.T0_turb027.num_points           = 281 81              \n",
      "turb027_.T0_turb027.origin               = 1489.523196492643 1329.7615982463215 27.0\n",
      "turb027_.T0_turb027.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb027_.T0_turb027.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb027_.T0_turb027.offset_vector        = 0.0 0.0 0.0         \n",
      "turb153_.T0_turb153.type                 = PlaneSampler        \n",
      "turb153_.T0_turb153.num_points           = 281 81              \n",
      "turb153_.T0_turb153.origin               = 1489.523196492643 1329.7615982463215 153.0\n",
      "turb153_.T0_turb153.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb153_.T0_turb153.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb153_.T0_turb153.offset_vector        = 0.0 0.0 0.0         \n",
      "turb216_.T0_turb216.type                 = PlaneSampler        \n",
      "turb216_.T0_turb216.num_points           = 281 81              \n",
      "turb216_.T0_turb216.origin               = 1489.523196492643 1329.7615982463215 216.0\n",
      "turb216_.T0_turb216.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb216_.T0_turb216.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb216_.T0_turb216.offset_vector        = 0.0 0.0 0.0         \n",
      "sideplane1_.T0_sideplane1.type           = PlaneSampler        \n",
      "sideplane1_.T0_sideplane1.num_points     = 281 45              \n",
      "sideplane1_.T0_sideplane1.origin         = 1363.523196492643 1548.0 1.8000000000000114\n",
      "sideplane1_.T0_sideplane1.axis1          = 1527.6688122757496 881.9999999999998 0.0\n",
      "sideplane1_.T0_sideplane1.axis2          = 0.0 0.0 277.2       \n",
      "sideplane1_.T0_sideplane1.offset_vector  = -0.4999999999999999 0.8660254037844386 -0.0\n",
      "sideplane1_.T0_sideplane1.offsets        = 0.0 252.0           \n",
      "sideplane2_.T0_sideplane2.type           = PlaneSampler        \n",
      "sideplane2_.T0_sideplane2.num_points     = 281 45              \n",
      "sideplane2_.T0_sideplane2.origin         = 1363.523196492643 1548.0 1.8000000000000114\n",
      "sideplane2_.T0_sideplane2.axis1          = 1527.6688122757496 881.9999999999998 0.0\n",
      "sideplane2_.T0_sideplane2.axis2          = 0.0 0.0 277.2       \n",
      "sideplane2_.T0_sideplane2.offset_vector  = -0.4999999999999999 0.8660254037844386 -0.0\n",
      "sideplane2_.T0_sideplane2.offsets        = 0.0 -252.0          \n",
      "XYdomain_027_.Farm_XYdomain027.type      = PlaneSampler        \n",
      "XYdomain_027_.Farm_XYdomain027.num_points = 513 513             \n",
      "XYdomain_027_.Farm_XYdomain027.origin    = 0.0001 0.0001 27.0  \n",
      "XYdomain_027_.Farm_XYdomain027.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_027_.Farm_XYdomain027.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_027_.Farm_XYdomain027.offset_vector = 0.0 0.0 0.0         \n",
      "XYdomain_090_.Farm_XYdomain090.type      = PlaneSampler        \n",
      "XYdomain_090_.Farm_XYdomain090.num_points = 513 513             \n",
      "XYdomain_090_.Farm_XYdomain090.origin    = 0.0001 0.0001 90.0  \n",
      "XYdomain_090_.Farm_XYdomain090.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_090_.Farm_XYdomain090.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_090_.Farm_XYdomain090.offset_vector = 0.0 0.0 0.0         \n",
      "XYdomain_153_.Farm_XYdomain153.type      = PlaneSampler        \n",
      "XYdomain_153_.Farm_XYdomain153.num_points = 513 513             \n",
      "XYdomain_153_.Farm_XYdomain153.origin    = 0.0001 0.0001 153.0 \n",
      "XYdomain_153_.Farm_XYdomain153.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_153_.Farm_XYdomain153.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_153_.Farm_XYdomain153.offset_vector = 0.0 0.0 0.0         \n",
      "\n",
      "#---- extra params ----\n",
      "io.KE_int                                = -1                  \n",
      "io.line_plot_int                         = 1                   \n",
      "CoriolisForcing.turn_off_vertical_force  = True                \n",
      "#== END AMR-WIND INPUT ==\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# For the w/o turbine ALM case\n",
    "case.removeturbines()\n",
    "print(case.writeAMRWindInput(noturboutputfile))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f3349e8-827d-4a98-a0f1-450044eb1618",
   "metadata": {
    "tags": []
   },
   "source": [
    "### For the blade resolved case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "babca755-ac1b-4eae-b5b3-0be3262597c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# --- Simulation time control parameters ---\n",
      "time.stop_time                           = 16000.0             # Max (simulated) time to evolve [s]\n",
      "time.max_step                            = -1                  \n",
      "time.fixed_dt                            = 0.003443526170799   # Fixed timestep size (in seconds). If negative, then time.cfl is used\n",
      "time.checkpoint_interval                 = 10000               \n",
      "time.checkpoint_start                    = 30000               \n",
      "incflo.physics                           = ABL                 # List of physics models to include in simulation.\n",
      "incflo.verbose                           = 0                   \n",
      "io.check_file                            = chk                 \n",
      "io.restart_file                          = /pscratch/ndeveld/hfm-2025-q1/abl/chk30000\n",
      "incflo.use_godunov                       = true                \n",
      "incflo.godunov_type                      = weno_z              \n",
      "turbulence.model                         = OneEqKsgsM84        \n",
      "TKE.source_terms                         = KsgsM84Src          \n",
      "nodal_proj.mg_rtol                       = 1e-08               \n",
      "nodal_proj.mg_atol                       = 1e-08               \n",
      "mac_proj.mg_rtol                         = 1e-08               \n",
      "mac_proj.mg_atol                         = 1e-08               \n",
      "diffusion.mg_rtol                        = 1e-08               \n",
      "diffusion.mg_atol                        = 1e-08               \n",
      "temperature_diffusion.mg_rtol            = 1e-08               \n",
      "temperature_diffusion.mg_atol            = 1e-08               \n",
      "incflo.gravity                           = 0.0 0.0 -9.81       # Gravitational acceleration vector (x,y,z) [m/s^2]\n",
      "incflo.density                           = 1.0                 # Fluid density [kg/m^3]\n",
      "transport.viscosity                      = 0.0                 # Fluid dynamic viscosity [kg/m-s]\n",
      "transport.laminar_prandtl                = 0.7                 # Laminar prandtl number\n",
      "transport.turbulent_prandtl              = 0.3333              # Turbulent prandtl number\n",
      "\n",
      "# --- Geometry and Mesh ---\n",
      "geometry.prob_lo                         = 0.0 0.0 0.0         \n",
      "geometry.prob_hi                         = 5120.0 5120.0 1920.0\n",
      "amr.n_cell                               = 512 512 192         # Number of cells in x, y, and z directions\n",
      "amr.max_level                            = 4                   \n",
      "geometry.is_periodic                     = 0 0 0               \n",
      "xlo.type                                 = mass_inflow         \n",
      "xlo.density                              = 1.0                 \n",
      "xlo.temperature                          = 0.0                 \n",
      "xlo.tke                                  = 0.0                 \n",
      "xhi.type                                 = pressure_outflow    \n",
      "ylo.type                                 = mass_inflow         \n",
      "ylo.density                              = 1.0                 \n",
      "ylo.temperature                          = 0.0                 \n",
      "ylo.tke                                  = 0.0                 \n",
      "yhi.type                                 = pressure_outflow    \n",
      "zlo.type                                 = wall_model          \n",
      "zlo.temperature_type                     = wall_model          \n",
      "zlo.tke_type                             = zero_gradient       \n",
      "zhi.type                                 = slip_wall           \n",
      "zhi.temperature_type                     = fixed_gradient      \n",
      "zhi.temperature                          = 0.003               \n",
      "\n",
      "# --- ABL parameters ---\n",
      "ICNS.source_terms                        = BoussinesqBuoyancy CoriolisForcing BodyForce ABLMeanBoussinesq\n",
      "ABL.stats_output_frequency               = 1                   \n",
      "ABL.stats_output_format                  = netcdf              \n",
      "ABL.tendency_forcing                     = false               \n",
      "ABL.bndry_io_mode                        = 1                   \n",
      "ABL.bndry_file                           = /tscratch/lcheung/HFM/exawind-benchmarks/convective_abl/bndry_file\n",
      "ABL.bndry_planes                         = xlo ylo             \n",
      "ABL.bndry_output_start_time              = 15000.0             \n",
      "ABL.bndry_var_names                      = velocity temperature tke\n",
      "ABL.bndry_output_format                  = native              \n",
      "incflo.velocity                          = 9.8726896031426 5.7 0.0\n",
      "ABLForcing.abl_forcing_height            = 90.0                \n",
      "ABL.kappa                                = 0.41                \n",
      "ABL.normal_direction                     = 2                   \n",
      "ABL.surface_roughness_z0                 = 0.01                \n",
      "ABL.reference_temperature                = 300.0               \n",
      "ABL.surface_temp_rate                    = 0.0                 \n",
      "ABL.surface_temp_flux                    = 0.005               # Surface temperature flux [K-m/s]\n",
      "ABL.log_law_height                       = 5.0                 \n",
      "ABL.wall_shear_stress_type               = local               \n",
      "ABL.wf_velocity                          = 6.0977889026612075 3.6097639593035185\n",
      "ABL.wf_vmag                              = 7.103916682319445   \n",
      "ABL.wf_theta                             = 300.20261481689676  \n",
      "CoriolisForcing.latitude                 = 40.0                \n",
      "CoriolisForcing.rotational_time_period   = 86400.0             \n",
      "CoriolisForcing.north_vector             = 0.0 1.0 0.0         \n",
      "CoriolisForcing.east_vector              = 1.0 0.0 0.0         \n",
      "BoussinesqBuoyancy.reference_temperature = 300.0               \n",
      "BodyForce.magnitude                      = -0.0002743665569299508 0.0011708563286373845 0.0\n",
      "ABL.temperature_heights                  = 0.0 750.0 850.0 2000.0\n",
      "ABL.temperature_values                   = 300.0 300.0 308.0 311.45\n",
      "ABLMeanBoussinesq.read_temperature_profile = true                \n",
      "ABLMeanBoussinesq.temperature_profile_filename = avg_theta.dat       \n",
      "ABL.perturb_velocity                     = true                \n",
      "ABL.perturb_ref_height                   = 50.0                \n",
      "ABL.Uperiods                             = 4.0                 \n",
      "ABL.Vperiods                             = 4.0                 \n",
      "ABL.deltaU                               = 1.0                 \n",
      "ABL.deltaV                               = 1.0                 \n",
      "ABL.perturb_temperature                  = true                \n",
      "ABL.theta_amplitude                      = 0.8                 \n",
      "ABL.cutoff_height                        = 50.0                \n",
      "time.plot_interval                       = 10000               \n",
      "io.plot_file                             = plt                 \n",
      "\n",
      "#---- tagging defs ----\n",
      "tagging.labels                           = T0_level_0_zone T0_level_1_zone T0_level_2_zone T0_level_3_zone\n",
      "tagging.T0_level_0_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_0_zone.shapes           = T0_level_0_zone     \n",
      "tagging.T0_level_0_zone.level            = 0                   \n",
      "tagging.T0_level_0_zone.T0_level_0_zone.type = box                 \n",
      "tagging.T0_level_0_zone.T0_level_0_zone.origin = 1569.4039956158035 939.4039956158036 -4.5\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.xaxis = 1636.788013152589 944.9999999999998 0.0\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.yaxis = -629.9999999999999 1091.1920087683927 -0.0\n",
      "tagging.T0_level_0_zone.T0_level_0_zone.zaxis = 0.0 0.0 346.5       \n",
      "tagging.T0_level_1_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_1_zone.shapes           = T0_level_1_zone     \n",
      "tagging.T0_level_1_zone.level            = 1                   \n",
      "tagging.T0_level_1_zone.T0_level_1_zone.type = box                 \n",
      "tagging.T0_level_1_zone.T0_level_1_zone.origin = 1653.2019978079018 1424.2615982463215 -4.5\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.xaxis = 818.3940065762945 472.4999999999999 0.0\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.yaxis = -251.99999999999994 436.47680350735703 -0.0\n",
      "tagging.T0_level_1_zone.T0_level_1_zone.zaxis = 0.0 0.0 283.5       \n",
      "tagging.T0_level_2_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_2_zone.shapes           = T0_level_2_zone     \n",
      "tagging.T0_level_2_zone.level            = 2                   \n",
      "tagging.T0_level_2_zone.T0_level_2_zone.type = box                 \n",
      "tagging.T0_level_2_zone.T0_level_2_zone.origin = 1742.350998903951 1584.850998903951 -4.5\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.xaxis = 354.6374028497276 204.74999999999994 0.0\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.yaxis = -157.49999999999997 272.7980021920982 -0.0\n",
      "tagging.T0_level_2_zone.T0_level_2_zone.zaxis = 0.0 0.0 220.5       \n",
      "tagging.T0_level_3_zone.type             = GeometryRefinement  \n",
      "tagging.T0_level_3_zone.shapes           = T0_level_3_zone     \n",
      "tagging.T0_level_3_zone.level            = 3                   \n",
      "tagging.T0_level_3_zone.T0_level_3_zone.type = box                 \n",
      "tagging.T0_level_3_zone.T0_level_3_zone.origin = 1781.1605993423705 1643.6307991231608 -4.5\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.xaxis = 163.6788013152589 94.49999999999999 0.0\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.yaxis = -125.99999999999997 218.23840175367852 -0.0\n",
      "tagging.T0_level_3_zone.T0_level_3_zone.zaxis = 0.0 0.0 189.0       \n",
      "\n",
      "#---- postprocessing defs ----\n",
      "incflo.post_processing                   = metmast_ rotorplaneUP_ rotorplaneDN_ nearwake_ turbsw_ turbhh_ turb027_ turb153_ turb216_ sideplane1_ sideplane2_ XYdomain_027_ XYdomain_090_ XYdomain_153_\n",
      "metmast_.type                            = Sampling            \n",
      "metmast_.output_frequency                = 1                   \n",
      "metmast_.fields                          = velocity temperature tke\n",
      "rotorplaneUP_.type                       = Sampling            \n",
      "rotorplaneUP_.output_frequency           = 50                  \n",
      "rotorplaneUP_.fields                     = velocity temperature tke\n",
      "rotorplaneDN_.type                       = Sampling            \n",
      "rotorplaneDN_.output_frequency           = 50                  \n",
      "rotorplaneDN_.fields                     = velocity temperature tke\n",
      "nearwake_.type                           = Sampling            \n",
      "nearwake_.output_frequency               = 50                  \n",
      "nearwake_.fields                         = velocity temperature tke\n",
      "turbsw_.type                             = Sampling            \n",
      "turbsw_.output_frequency                 = 50                  \n",
      "turbsw_.fields                           = velocity temperature tke\n",
      "turbhh_.type                             = Sampling            \n",
      "turbhh_.output_frequency                 = 50                  \n",
      "turbhh_.fields                           = velocity temperature tke\n",
      "turb027_.type                            = Sampling            \n",
      "turb027_.output_frequency                = 50                  \n",
      "turb027_.fields                          = velocity temperature tke\n",
      "turb153_.type                            = Sampling            \n",
      "turb153_.output_frequency                = 50                  \n",
      "turb153_.fields                          = velocity temperature tke\n",
      "turb216_.type                            = Sampling            \n",
      "turb216_.output_frequency                = 50                  \n",
      "turb216_.fields                          = velocity temperature tke\n",
      "sideplane1_.type                         = Sampling            \n",
      "sideplane1_.output_frequency             = 50                  \n",
      "sideplane1_.fields                       = velocity temperature tke\n",
      "sideplane2_.type                         = Sampling            \n",
      "sideplane2_.output_frequency             = 50                  \n",
      "sideplane2_.fields                       = velocity temperature tke\n",
      "XYdomain_027_.type                       = Sampling            \n",
      "XYdomain_027_.output_frequency           = 50                  \n",
      "XYdomain_027_.fields                     = velocity temperature tke\n",
      "XYdomain_090_.type                       = Sampling            \n",
      "XYdomain_090_.output_frequency           = 50                  \n",
      "XYdomain_090_.fields                     = velocity temperature tke\n",
      "XYdomain_153_.type                       = Sampling            \n",
      "XYdomain_153_.output_frequency           = 50                  \n",
      "XYdomain_153_.fields                     = velocity temperature tke\n",
      "\n",
      "#---- sample defs ----\n",
      "metmast_.labels                          = virtualmast         \n",
      "rotorplaneUP_.labels                     = T0_rotorplaneUP     \n",
      "rotorplaneDN_.labels                     = T0_rotorplaneDN     \n",
      "nearwake_.labels                         = T0_nearwake         \n",
      "turbsw_.labels                           = T0_turbsw           \n",
      "turbhh_.labels                           = T0_turbhh           \n",
      "turb027_.labels                          = T0_turb027          \n",
      "turb153_.labels                          = T0_turb153          \n",
      "turb216_.labels                          = T0_turb216          \n",
      "sideplane1_.labels                       = T0_sideplane1       \n",
      "sideplane2_.labels                       = T0_sideplane2       \n",
      "XYdomain_027_.labels                     = Farm_XYdomain027    \n",
      "XYdomain_090_.labels                     = Farm_XYdomain090    \n",
      "XYdomain_153_.labels                     = Farm_XYdomain153    \n",
      "metmast_.virtualmast.type                = LineSampler         \n",
      "metmast_.virtualmast.num_points          = 20                  \n",
      "metmast_.virtualmast.start               = 1800.0 1800.0 10.0  \n",
      "metmast_.virtualmast.end                 = 1800.0 1800.0 200.0 \n",
      "rotorplaneUP_.T0_rotorplaneUP.type       = PlaneSampler        \n",
      "rotorplaneUP_.T0_rotorplaneUP.num_points = 81 35               \n",
      "rotorplaneUP_.T0_rotorplaneUP.origin     = 1489.523196492643 1329.7615982463215 1.8000000000000114\n",
      "rotorplaneUP_.T0_rotorplaneUP.axis1      = -251.99999999999994 436.47680350735703 -0.0\n",
      "rotorplaneUP_.T0_rotorplaneUP.axis2      = 0.0 0.0 214.2       \n",
      "rotorplaneUP_.T0_rotorplaneUP.offset_vector = 0.8660254037844386 0.4999999999999999 0.0\n",
      "rotorplaneUP_.T0_rotorplaneUP.offsets    = 0.0 126.0 252.0 378.0 504.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.type       = PlaneSampler        \n",
      "rotorplaneDN_.T0_rotorplaneDN.num_points = 81 35               \n",
      "rotorplaneDN_.T0_rotorplaneDN.origin     = 1926.0 1581.7615982463215 1.8000000000000114\n",
      "rotorplaneDN_.T0_rotorplaneDN.axis1      = -251.99999999999994 436.47680350735703 -0.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.axis2      = 0.0 0.0 214.2       \n",
      "rotorplaneDN_.T0_rotorplaneDN.offset_vector = 0.8660254037844386 0.4999999999999999 0.0\n",
      "rotorplaneDN_.T0_rotorplaneDN.offsets    = 0.0 126.0 252.0 378.0 504.0 630.0 756.0 882.0 1008.0 1134.0 1260.0\n",
      "nearwake_.T0_nearwake.type               = PlaneSampler        \n",
      "nearwake_.T0_nearwake.num_points         = 81 35               \n",
      "nearwake_.T0_nearwake.origin             = 1926.0 1581.7615982463215 1.8000000000000114\n",
      "nearwake_.T0_nearwake.axis1              = -251.99999999999994 436.47680350735703 -0.0\n",
      "nearwake_.T0_nearwake.axis2              = 0.0 0.0 214.2       \n",
      "nearwake_.T0_nearwake.offset_vector      = 0.8660254037844386 0.4999999999999999 0.0\n",
      "nearwake_.T0_nearwake.offsets            = 0.0 63.0 126.0 189.0 252.0\n",
      "turbsw_.T0_turbsw.type                   = PlaneSampler        \n",
      "turbsw_.T0_turbsw.num_points             = 281 45              \n",
      "turbsw_.T0_turbsw.origin                 = 1363.523196492643 1548.0 1.8000000000000114\n",
      "turbsw_.T0_turbsw.axis1                  = 1527.6688122757496 881.9999999999998 0.0\n",
      "turbsw_.T0_turbsw.axis2                  = 0.0 0.0 277.2       \n",
      "turbsw_.T0_turbsw.offset_vector          = 0.0 0.0 0.0         \n",
      "turbhh_.T0_turbhh.type                   = PlaneSampler        \n",
      "turbhh_.T0_turbhh.num_points             = 281 81              \n",
      "turbhh_.T0_turbhh.origin                 = 1489.523196492643 1329.7615982463215 90.0\n",
      "turbhh_.T0_turbhh.axis1                  = 1527.6688122757496 881.9999999999998 0.0\n",
      "turbhh_.T0_turbhh.axis2                  = -251.99999999999994 436.47680350735703 -0.0\n",
      "turbhh_.T0_turbhh.offset_vector          = 0.0 0.0 0.0         \n",
      "turb027_.T0_turb027.type                 = PlaneSampler        \n",
      "turb027_.T0_turb027.num_points           = 281 81              \n",
      "turb027_.T0_turb027.origin               = 1489.523196492643 1329.7615982463215 27.0\n",
      "turb027_.T0_turb027.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb027_.T0_turb027.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb027_.T0_turb027.offset_vector        = 0.0 0.0 0.0         \n",
      "turb153_.T0_turb153.type                 = PlaneSampler        \n",
      "turb153_.T0_turb153.num_points           = 281 81              \n",
      "turb153_.T0_turb153.origin               = 1489.523196492643 1329.7615982463215 153.0\n",
      "turb153_.T0_turb153.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb153_.T0_turb153.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb153_.T0_turb153.offset_vector        = 0.0 0.0 0.0         \n",
      "turb216_.T0_turb216.type                 = PlaneSampler        \n",
      "turb216_.T0_turb216.num_points           = 281 81              \n",
      "turb216_.T0_turb216.origin               = 1489.523196492643 1329.7615982463215 216.0\n",
      "turb216_.T0_turb216.axis1                = 1527.6688122757496 881.9999999999998 0.0\n",
      "turb216_.T0_turb216.axis2                = -251.99999999999994 436.47680350735703 -0.0\n",
      "turb216_.T0_turb216.offset_vector        = 0.0 0.0 0.0         \n",
      "sideplane1_.T0_sideplane1.type           = PlaneSampler        \n",
      "sideplane1_.T0_sideplane1.num_points     = 281 45              \n",
      "sideplane1_.T0_sideplane1.origin         = 1363.523196492643 1548.0 1.8000000000000114\n",
      "sideplane1_.T0_sideplane1.axis1          = 1527.6688122757496 881.9999999999998 0.0\n",
      "sideplane1_.T0_sideplane1.axis2          = 0.0 0.0 277.2       \n",
      "sideplane1_.T0_sideplane1.offset_vector  = -0.4999999999999999 0.8660254037844386 -0.0\n",
      "sideplane1_.T0_sideplane1.offsets        = 0.0 252.0           \n",
      "sideplane2_.T0_sideplane2.type           = PlaneSampler        \n",
      "sideplane2_.T0_sideplane2.num_points     = 281 45              \n",
      "sideplane2_.T0_sideplane2.origin         = 1363.523196492643 1548.0 1.8000000000000114\n",
      "sideplane2_.T0_sideplane2.axis1          = 1527.6688122757496 881.9999999999998 0.0\n",
      "sideplane2_.T0_sideplane2.axis2          = 0.0 0.0 277.2       \n",
      "sideplane2_.T0_sideplane2.offset_vector  = -0.4999999999999999 0.8660254037844386 -0.0\n",
      "sideplane2_.T0_sideplane2.offsets        = 0.0 -252.0          \n",
      "XYdomain_027_.Farm_XYdomain027.type      = PlaneSampler        \n",
      "XYdomain_027_.Farm_XYdomain027.num_points = 513 513             \n",
      "XYdomain_027_.Farm_XYdomain027.origin    = 0.0001 0.0001 27.0  \n",
      "XYdomain_027_.Farm_XYdomain027.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_027_.Farm_XYdomain027.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_027_.Farm_XYdomain027.offset_vector = 0.0 0.0 0.0         \n",
      "XYdomain_090_.Farm_XYdomain090.type      = PlaneSampler        \n",
      "XYdomain_090_.Farm_XYdomain090.num_points = 513 513             \n",
      "XYdomain_090_.Farm_XYdomain090.origin    = 0.0001 0.0001 90.0  \n",
      "XYdomain_090_.Farm_XYdomain090.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_090_.Farm_XYdomain090.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_090_.Farm_XYdomain090.offset_vector = 0.0 0.0 0.0         \n",
      "XYdomain_153_.Farm_XYdomain153.type      = PlaneSampler        \n",
      "XYdomain_153_.Farm_XYdomain153.num_points = 513 513             \n",
      "XYdomain_153_.Farm_XYdomain153.origin    = 0.0001 0.0001 153.0 \n",
      "XYdomain_153_.Farm_XYdomain153.axis1     = 5119.9998 0.0 0.0   \n",
      "XYdomain_153_.Farm_XYdomain153.axis2     = 0.0 5119.9998 0.0   \n",
      "XYdomain_153_.Farm_XYdomain153.offset_vector = 0.0 0.0 0.0         \n",
      "\n",
      "#---- extra params ----\n",
      "ABL.enable_hybrid_rl_mode                = true                \n",
      "amr.max_grid_size                        = 128                 \n",
      "amr.blocking_factor                      = 32                  \n",
      "nodal_proj.num_pre_smooth                = 10                  \n",
      "nodal_proj.num_post_smooth               = 10                  \n",
      "nodal_proj.bottom_rtol                   = 1.0e-9              \n",
      "nodal_proj.bottom_atol                   = 1.0e-12             \n",
      "mac_proj.verbose                         = 0                   \n",
      "mac_proj.do_nsolve                       = true                \n",
      "mac_proj.bottom_verbose                  = 0                   \n",
      "mac_proj.bottom_rtol                     = 1.0e-11             \n",
      "mac_proj.bottom_atol                     = 1.0e-12             \n",
      "mac_proj.num_pre_smooth                  = 10                  \n",
      "mac_proj.num_post_smooth                 = 10                  \n",
      "diffusion.verbose                        = 0                   \n",
      "diffusion.do_agglomeration               = false               \n",
      "diffusion.do_nsolve                      = true                \n",
      "velocity_diffusion.verbose               = 0                   \n",
      "velocity_diffusion.use_tensor_operator   = false               \n",
      "velocity_diffusion.use_segregated_operator = true                \n",
      "velocity_diffusion.do_nsolve             = true                \n",
      "temperature_diffusion.verbose            = 0                   \n",
      "temperature_diffusion.do_nsolve          = true                \n",
      "amrex.abort_on_out_of_gpu_memory         = 1                   \n",
      "amrex.the_arena_is_managed               = 0                   \n",
      "amrex.hypre_spgemm_use_vendor            = 1                   \n",
      "amrex.hypre_spmv_use_vendor              = 0                   \n",
      "amrex.hypre_sptrans_use_vendor           = 0                   \n",
      "amrex.hypre_umpire_device_pool_mbs       = 4096                \n",
      "hypre.bamg_verbose                       = 0                   \n",
      "hypre.verbose                            = 0                   \n",
      "hypre.recompute_preconditioner           = 0                   \n",
      "hypre.hypre_solver                       = GMRES               \n",
      "hypre.hypre_preconditioner               = BoomerAMG           \n",
      "hypre.num_krylov                         = 40                  \n",
      "hypre.max_iterations                     = 40                  \n",
      "hypre.rtol                               = 1.e-5               \n",
      "hypre.atol                               = 1.e-8               \n",
      "hypre.bamg_coarsen_type                  = 8                   \n",
      "hypre.bamg_interp_type                   = 6                   \n",
      "hypre.bamg_relax_type                    = 11                  \n",
      "hypre.bamg_num_sweeps                    = 2                   \n",
      "hypre.bamg_cycle_type                    = 1                   \n",
      "hypre.bamg_relax_order                   = 0                   \n",
      "hypre.bamg_trunc_factor                  = 0.45                \n",
      "hypre.bamg_strong_threshold              = 0.3                 \n",
      "hypre.bamg_min_coarse_size               = 1                   \n",
      "hypre.bamg_max_coarse_size               = 100                 \n",
      "hypre.bamg_agg_num_levels                = 0                   \n",
      "hypre.bamg_agg_interp_type               = 7                   \n",
      "hypre.bamg_agg_pmax_elmts                = 3                   \n",
      "hypre.bamg_pmax_elmts                    = 3                   \n",
      "hypre.bamg_keep_transpose                = 1                   \n",
      "hypre.write_matrix_files                 = 0                   \n",
      "hypre.bamg_smooth_type                   = 5                   \n",
      "hypre.bamg_smooth_num_sweeps             = 1                   \n",
      "hypre.bamg_smooth_num_levels             = 0                   \n",
      "hypre.bamg_ilu_type                      = 0                   \n",
      "hypre.bamg_ilu_level                     = 0                   \n",
      "hypre.bamg_ilu_max_iter                  = 1                   \n",
      "hypre.bamg_ilu_reordering_type           = 0                   \n",
      "hypre.bamg_ilu_tri_solve                 = 0                   \n",
      "hypre.bamg_ilu_lower_jacobi_iters        = 3                   \n",
      "hypre.bamg_ilu_upper_jacobi_iters        = 3                   \n",
      "#== END AMR-WIND INPUT ==\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# For the blade resolved case\n",
    "case.setAMRWindInput('amr.max_level',  4)\n",
    "case.setAMRWindInput('time.fixed_dt',  0.003443526170799) # = OFdt*4\n",
    "\n",
    "# These are extra parameters needed for the hybrid solver\n",
    "extraparams = \"\"\"\n",
    "ABL.enable_hybrid_rl_mode                = true                \n",
    "amr.max_grid_size                        = 128                 \n",
    "amr.blocking_factor                      = 32                  \n",
    "nodal_proj.num_pre_smooth                = 10                  \n",
    "nodal_proj.num_post_smooth               = 10                  \n",
    "nodal_proj.bottom_rtol                   = 1.0e-9              \n",
    "nodal_proj.bottom_atol                   = 1.0e-12             \n",
    "mac_proj.verbose                         = 0                   \n",
    "mac_proj.do_nsolve                       = true                \n",
    "mac_proj.bottom_verbose                  = 0                   \n",
    "mac_proj.bottom_rtol                     = 1.0e-11             \n",
    "mac_proj.bottom_atol                     = 1.0e-12             \n",
    "mac_proj.num_pre_smooth                  = 10                  \n",
    "mac_proj.num_post_smooth                 = 10                  \n",
    "diffusion.verbose                        = 0                   \n",
    "diffusion.do_agglomeration               = false               \n",
    "diffusion.do_nsolve                      = true                \n",
    "velocity_diffusion.verbose               = 0                   \n",
    "velocity_diffusion.use_tensor_operator   = false               \n",
    "velocity_diffusion.use_segregated_operator = true                \n",
    "velocity_diffusion.do_nsolve             = true                \n",
    "temperature_diffusion.verbose            = 0                   \n",
    "temperature_diffusion.do_nsolve          = true                \n",
    "amrex.abort_on_out_of_gpu_memory         = 1                   \n",
    "amrex.the_arena_is_managed               = 0                   \n",
    "amrex.hypre_spgemm_use_vendor            = 1                   \n",
    "amrex.hypre_spmv_use_vendor              = 0                   \n",
    "amrex.hypre_sptrans_use_vendor           = 0                   \n",
    "amrex.hypre_umpire_device_pool_mbs       = 4096                \n",
    "hypre.bamg_verbose                       = 0                   \n",
    "hypre.verbose                            = 0                   \n",
    "hypre.recompute_preconditioner           = 0                   \n",
    "hypre.hypre_solver                       = GMRES               \n",
    "hypre.hypre_preconditioner               = BoomerAMG           \n",
    "hypre.num_krylov                         = 40                  \n",
    "hypre.max_iterations                     = 40                  \n",
    "hypre.rtol                               = 1.e-5               \n",
    "hypre.atol                               = 1.e-8               \n",
    "hypre.bamg_coarsen_type                  = 8                   \n",
    "hypre.bamg_interp_type                   = 6                   \n",
    "hypre.bamg_relax_type                    = 11                  \n",
    "hypre.bamg_num_sweeps                    = 2                   \n",
    "hypre.bamg_cycle_type                    = 1                   \n",
    "hypre.bamg_relax_order                   = 0                   \n",
    "hypre.bamg_trunc_factor                  = 0.45                \n",
    "hypre.bamg_strong_threshold              = 0.3                 \n",
    "hypre.bamg_min_coarse_size               = 1                   \n",
    "hypre.bamg_max_coarse_size               = 100                 \n",
    "hypre.bamg_agg_num_levels                = 0                   \n",
    "hypre.bamg_agg_interp_type               = 7                   \n",
    "hypre.bamg_agg_pmax_elmts                = 3                   \n",
    "hypre.bamg_pmax_elmts                    = 3                   \n",
    "hypre.bamg_keep_transpose                = 1                   \n",
    "hypre.write_matrix_files                 = 0                   \n",
    "hypre.bamg_smooth_type                   = 5                   \n",
    "hypre.bamg_smooth_num_sweeps             = 1                   \n",
    "hypre.bamg_smooth_num_levels             = 0                   \n",
    "hypre.bamg_ilu_type                      = 0                   \n",
    "hypre.bamg_ilu_level                     = 0                   \n",
    "hypre.bamg_ilu_max_iter                  = 1                   \n",
    "hypre.bamg_ilu_reordering_type           = 0                   \n",
    "hypre.bamg_ilu_tri_solve                 = 0                   \n",
    "hypre.bamg_ilu_lower_jacobi_iters        = 3                   \n",
    "hypre.bamg_ilu_upper_jacobi_iters        = 3                   \n",
    "\"\"\"\n",
    "case.loadAMRWindInput(extraparams, string=True);\n",
    "print(case.writeAMRWindInput(BRoutputfile))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "556d3573-ca75-4394-9f4a-d5ee94199f7e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}