diff --git a/.github/workflows/test_pvade.yaml b/.github/workflows/test_pvade.yaml
index c92cd140..897d46c5 100644
--- a/.github/workflows/test_pvade.yaml
+++ b/.github/workflows/test_pvade.yaml
@@ -25,10 +25,16 @@ jobs:
       - name: Build Conda environment
         uses: conda-incubator/setup-miniconda@v3
         with:
+          # auto-update-conda: true
+          python-version: "3.10"
           environment-file: environment.yaml
+          activate-environment: pvade
       - name: Run pytest
         shell: bash -l {0}
-        run: pytest -sv pvade/tests/
+        run: PYTHONPATH=. pytest -sv pvade/tests/
+      - name: test all inputs
+        shell: bash -l {0}
+        run: pytest -sv  test_all_inputs.py 
 
   # Job 2 of 2 - enforce Black formatting
   formatting:
diff --git a/.gitignore b/.gitignore
index 5b92f102..65bed47d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,4 +8,5 @@
 *.h5
 
 docs/_build/
-results/
\ No newline at end of file
+results/input/
+input/
diff --git a/conftest.py b/conftest.py
new file mode 100644
index 00000000..05a95be0
--- /dev/null
+++ b/conftest.py
@@ -0,0 +1,29 @@
+from pathlib import Path
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--input-file",
+        action="store",
+        default=None,
+        help="Run test only for a specific input YAML file",
+    )
+
+
+def pytest_generate_tests(metafunc):
+    if "input_file" not in metafunc.fixturenames:
+        return
+
+    input_file_arg = metafunc.config.getoption("input_file")
+
+    if input_file_arg:
+        metafunc.parametrize("input_file", [Path(input_file_arg)])
+    else:
+        # 🔧 Always resolve input/ relative to location of conftest.py (PVade/)
+        this_dir = Path(__file__).resolve().parent  # PVade/
+        input_dir = this_dir / "input"
+
+        all_files = sorted(input_dir.glob("*.yaml"))
+        if not all_files:
+            raise RuntimeError(f"No input files found in {input_dir}")
+        metafunc.parametrize("input_file", all_files)
diff --git a/docs/how_to_guides/examples/Turbulent_Inflow_Panels_3D.rst b/docs/how_to_guides/examples/Turbulent_Inflow_Panels_3D.rst
new file mode 100644
index 00000000..5e6a4ec4
--- /dev/null
+++ b/docs/how_to_guides/examples/Turbulent_Inflow_Panels_3D.rst
@@ -0,0 +1,94 @@
+PV Panels 3D with Turbulent Inflow
+===========
+This example demonstrates the use of PVade to simulate dynamic PV loading amidst a turbulent inflow velocity field. 
+
+Currently, this feature only works in 3D simulations.
+
+Geometry Definition
+-------------------
+
+
+This example consists of a turbulent atmospheric flow in which the fluid interacts with a single row of PV panels. The domain setup and geometry are described in the figure below.
+
+.. image:: pictures/turbinflow3d/duramat_dimensions.png
+  :alt: Alternative text
+
+where: 
+
+chord is the length of the solar panel, 
+span is the width of the solar panel, 
+elevation is the height of the mounting point, and
+tracker angle is the tilt angle of the solar panel.
+
+
+.. image:: pictures/turbinflow3d/turb_inflow_domain_setup.png
+  :alt: Alternative text
+
+L is the length of the domain and
+H is the height of the domain.
+
+
+For this example, the following values are used, as shown in the input file (``input/turbinflow_duramat_case_study.yaml``):
+
+.. container::
+   :name: tab:geometry
+
+   .. table:: Parameter settings
+
+      ==================================== =====
+      parameter [units]                    Value
+      ==================================== =====
+      L [m]                                80
+      H [m]                                20
+      chord [m]                            4.1
+      span [m]                             10.0
+      elevation [m]                        2.1
+      tracker angle [degrees]              0
+      ==================================== =====
+
+
+Synthetic Turbulence Generation
+-------------------------------
+
+The turbulent inflow velocity field is generated externally using `pyconturb` [1]_. This example uses unconstrained turbulence generated using the notebook here: ``examples/synthetic_turbulent_inflow/generate_turbulent_inflow_h5_file.ipynb``.
+
+The generated turbulent velocity field is written to an .h5 file (e.g. ``input/pct_turb_ny80_nz80_unconstrained_1.0s_dt0.01_uref20.h5``) so that it can be read in by `pvade`. This file contains velocity data of shape (nt, ny, nz) where nt = number of timesteps, ny = number of gridpoints in the spanwise direction, and nz = number of gridpoints in the vertical direction. At each timestep, `pvade` selects the y-z slice of turbulent inflow for that timestep and applies it as the boundary condition at the inlet.
+
+Currently, this functionality only works for 3D simulations.
+
+Running this example locally
+----------------------------
+
+This example is executed in parallel using::
+
+  mpirun -n 8 python pvade_main.py --input_file input/turbinflow_duramat_case_study.yaml
+
+For testing purposes, this example can be run for less time using::
+
+  mpirun -n 8 python pvade_main.py --input_file input/turbinflow_duramat_case_study.yaml --domain.l_char 2.5 --solver.t_final 0.2
+
+
+Running this example on HPC
+---------------------------
+
+This example is best run on a supercomputer using the included batch script as an example(``PVade/docs/how_to_guides/examples/runscripts/run.sh``). You will need to change the environment path and the paths to the files to your own.
+
+First, create a symbolic link to the ``input`` folder from where you are launching the simulation::
+
+    ln -s <path_to_PVade>/input input
+
+Then, edit and run the following script to launch the simulation::
+
+    sbatch run.sh
+
+For more details on running on HPC, please refer to :ref:`Running on HPC`.
+
+This example yields the following result:
+
+.. image:: pictures/turbinflow3d/turb_inflow_slices.gif
+  :alt: Alternative text
+
+
+References
+----------
+.. [1] J. M. Rinker, “PyConTurb: Constrained Stochastic Turbulence for Wind Energy Applications,” 2017, https://gitlab.windenergy.dtu.dk/pyconturb/pyconturb
diff --git a/docs/how_to_guides/examples/index.rst b/docs/how_to_guides/examples/index.rst
index 608808ed..1b410909 100644
--- a/docs/how_to_guides/examples/index.rst
+++ b/docs/how_to_guides/examples/index.rst
@@ -5,6 +5,7 @@ Examples
    :maxdepth: 1
 
    Flag_2D
+   Turbulent_Inflow_Panels_3D
    Heliostat_3D
 ..   Cylinder_2D
 ..   Cylinder_3D
diff --git a/docs/how_to_guides/examples/pictures/turbinflow3d/duramat_dimensions.png b/docs/how_to_guides/examples/pictures/turbinflow3d/duramat_dimensions.png
new file mode 100644
index 00000000..dfff18ea
Binary files /dev/null and b/docs/how_to_guides/examples/pictures/turbinflow3d/duramat_dimensions.png differ
diff --git a/docs/how_to_guides/examples/pictures/turbinflow3d/turb_inflow_domain_setup.png b/docs/how_to_guides/examples/pictures/turbinflow3d/turb_inflow_domain_setup.png
new file mode 100644
index 00000000..f455d189
Binary files /dev/null and b/docs/how_to_guides/examples/pictures/turbinflow3d/turb_inflow_domain_setup.png differ
diff --git a/docs/how_to_guides/examples/pictures/turbinflow3d/turb_inflow_slices.gif b/docs/how_to_guides/examples/pictures/turbinflow3d/turb_inflow_slices.gif
new file mode 100644
index 00000000..945ba85c
Binary files /dev/null and b/docs/how_to_guides/examples/pictures/turbinflow3d/turb_inflow_slices.gif differ
diff --git a/docs/how_to_guides/examples/runscripts/run.sh b/docs/how_to_guides/examples/runscripts/run.sh
index d5a0fad7..03d6a2d3 100644
--- a/docs/how_to_guides/examples/runscripts/run.sh
+++ b/docs/how_to_guides/examples/runscripts/run.sh
@@ -2,11 +2,11 @@
 
 #SBATCH --ntasks-per-node=104
 #SBATCH --time=08:00:00
-#SBATCH --account=csphfm
-#SBATCH --job-name=heliostat_u2
+#SBATCH --account=pvopt
+#SBATCH --job-name=jobname
 #SBATCH --nodes=1
-#SBATCH --error=heliostat-0.err
-#SBATCH --output=heliostat-0.out
+#SBATCH --error=jobname.err
+#SBATCH --output=jobname.out
 #SBATCH --mem=0
 #SBATCH --exclusive
 
@@ -15,4 +15,4 @@ module load mamba
 mamba activate pvade
 export OMP_NUM_THREADS=1
 
-mpirun -np 104 python -u /home/bstanisl/pvade/PVade/ns_main.py --input_file /home/bstanisl/pvade/PVade/input/single_heliostat.yaml
+mpirun -np 104 python -u /home/bstanisl/pvade/PVade/pvade_main.py --input_file /home/bstanisl/pvade/PVade/input/<input_yaml_file>
diff --git a/docs/how_to_guides/pvade_input_file.rst b/docs/how_to_guides/pvade_input_file.rst
index 2086e1a8..a761c082 100644
--- a/docs/how_to_guides/pvade_input_file.rst
+++ b/docs/how_to_guides/pvade_input_file.rst
@@ -98,6 +98,8 @@ solver:
 fluid:
   The fluid Category sets the CFD parameters for the fluid simulation
    
+  - velocity_profile_type: General shape of inflow velocity profile
+  - initialize_with_inflow_bc: Boolean flag to set the velocity everywhere in the domain to match the inflow BC velocity.
   - u_ref: Reference velocity at the center of the panel  
   - nu: Dynamic viscosity 
   - turbulence_model:  can be set to smagorinsky or null for no turbulence  
@@ -114,7 +116,7 @@ structure:
 
   - dt : set the time step for the CSD simulation 
   - elasticity_modulus: set the Elasticity modulus for the structure 
-  - poissons_ratio: set poisson's ration for the structure
+  - poissons_ratio: set poisson's ratio for the structure
   - body_force_x: set the x component of the body force 
   - body_force_y: set the y component of the body force
   - body_force_z: set the z component of the body force
diff --git a/environment.yaml b/environment.yaml
index b404c28f..45b7fa4d 100644
--- a/environment.yaml
+++ b/environment.yaml
@@ -1,12 +1,14 @@
-name: pvade
+name: pvade-test
 channels:
   - conda-forge  
-  - defaults
+  - nodefaults
 dependencies:
   # Dependencies should be kept as loosely pinned to version numbers as possible
+  - python >=3.10,<3.11
   - alive-progress
   - black
   - fenics-dolfinx=0.6
+  - h5py
   - jsonschema
   - jupyter
   - matplotlib
@@ -21,6 +23,7 @@ dependencies:
   - sphinx
   - tqdm
   - pip
+  - mpich >=4.0,<5.0
   - pip:
     - sphinx-rtd-theme
     - sphinxcontrib.datatemplates
diff --git a/examples/synthetic_turbulent_inflow/generate_turbulent_inflow_h5_file.ipynb b/examples/synthetic_turbulent_inflow/generate_turbulent_inflow_h5_file.ipynb
new file mode 100644
index 00000000..be392721
--- /dev/null
+++ b/examples/synthetic_turbulent_inflow/generate_turbulent_inflow_h5_file.ipynb
@@ -0,0 +1,596 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "91372fff",
+   "metadata": {},
+   "source": [
+    "## Use PyConTurb to generate synthetic turbulent inflow velocity field ##\n",
+    "\n",
+    "If you haven't already, install `pyconturb` using the instructions here: https://pyconturb.pages.windenergy.dtu.dk/pyconturb/installation.html\n",
+    "\n",
+    "This notebook follows the Unconstrained Turbulence example here: https://pyconturb.pages.windenergy.dtu.dk/pyconturb/notebooks/1_unconstr_time_series.html "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4c49110b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt  # matplotlib for some plotting\n",
+    "import numpy as np  # numeric python functions\n",
+    "import pandas as pd  # need this to load our data from the csv files\n",
+    "\n",
+    "import sys\n",
+    "# NOTE: to run this, you will need to replace the path below #\n",
+    "sys.path.append('/Users/bstanisl/repos/pyconturb/pyconturb') # path to the pyconturb repository location on your local machine\n",
+    "from pyconturb import gen_turb, gen_spat_grid  # generate turbulence, useful helper\n",
+    "from pyconturb.sig_models import iec_sig  # IEC 61400-1 turbulence std dev\n",
+    "from pyconturb.spectral_models import kaimal_spectrum  # Kaimal spectrum\n",
+    "from pyconturb.wind_profiles import constant_profile, power_profile  # wind-speed profile functions\n",
+    "\n",
+    "from _nb_utils import plot_slice\n",
+    "import h5py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a1b8d1b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>u_p0</th>\n",
+       "      <th>v_p0</th>\n",
+       "      <th>w_p0</th>\n",
+       "      <th>u_p1</th>\n",
+       "      <th>v_p1</th>\n",
+       "      <th>w_p1</th>\n",
+       "      <th>u_p2</th>\n",
+       "      <th>v_p2</th>\n",
+       "      <th>w_p2</th>\n",
+       "      <th>u_p3</th>\n",
+       "      <th>...</th>\n",
+       "      <th>w_p6396</th>\n",
+       "      <th>u_p6397</th>\n",
+       "      <th>v_p6397</th>\n",
+       "      <th>w_p6397</th>\n",
+       "      <th>u_p6398</th>\n",
+       "      <th>v_p6398</th>\n",
+       "      <th>w_p6398</th>\n",
+       "      <th>u_p6399</th>\n",
+       "      <th>v_p6399</th>\n",
+       "      <th>w_p6399</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>k</th>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>1.00000</td>\n",
+       "      <td>2.00000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>2.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>2.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>2.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>2.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>2.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>x</th>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>y</th>\n",
+       "      <td>-10.00000</td>\n",
+       "      <td>-10.00000</td>\n",
+       "      <td>-10.00000</td>\n",
+       "      <td>-10.000000</td>\n",
+       "      <td>-10.000000</td>\n",
+       "      <td>-10.000000</td>\n",
+       "      <td>-10.000000</td>\n",
+       "      <td>-10.000000</td>\n",
+       "      <td>-10.000000</td>\n",
+       "      <td>-10.000000</td>\n",
+       "      <td>...</td>\n",
+       "      <td>10.000000</td>\n",
+       "      <td>10.000000</td>\n",
+       "      <td>10.000000</td>\n",
+       "      <td>10.000000</td>\n",
+       "      <td>10.000000</td>\n",
+       "      <td>10.000000</td>\n",
+       "      <td>10.000000</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>10.0</td>\n",
+       "      <td>10.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>z</th>\n",
+       "      <td>0.00001</td>\n",
+       "      <td>0.00001</td>\n",
+       "      <td>0.00001</td>\n",
+       "      <td>0.253174</td>\n",
+       "      <td>0.253174</td>\n",
+       "      <td>0.253174</td>\n",
+       "      <td>0.506339</td>\n",
+       "      <td>0.506339</td>\n",
+       "      <td>0.506339</td>\n",
+       "      <td>0.759503</td>\n",
+       "      <td>...</td>\n",
+       "      <td>19.240507</td>\n",
+       "      <td>19.493671</td>\n",
+       "      <td>19.493671</td>\n",
+       "      <td>19.493671</td>\n",
+       "      <td>19.746836</td>\n",
+       "      <td>19.746836</td>\n",
+       "      <td>19.746836</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>20.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>4 rows × 19200 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       u_p0      v_p0      w_p0       u_p1       v_p1       w_p1       u_p2  \\\n",
+       "k   0.00000   1.00000   2.00000   0.000000   1.000000   2.000000   0.000000   \n",
+       "x   0.00000   0.00000   0.00000   0.000000   0.000000   0.000000   0.000000   \n",
+       "y -10.00000 -10.00000 -10.00000 -10.000000 -10.000000 -10.000000 -10.000000   \n",
+       "z   0.00001   0.00001   0.00001   0.253174   0.253174   0.253174   0.506339   \n",
+       "\n",
+       "        v_p2       w_p2       u_p3  ...    w_p6396    u_p6397    v_p6397  \\\n",
+       "k   1.000000   2.000000   0.000000  ...   2.000000   0.000000   1.000000   \n",
+       "x   0.000000   0.000000   0.000000  ...   0.000000   0.000000   0.000000   \n",
+       "y -10.000000 -10.000000 -10.000000  ...  10.000000  10.000000  10.000000   \n",
+       "z   0.506339   0.506339   0.759503  ...  19.240507  19.493671  19.493671   \n",
+       "\n",
+       "     w_p6397    u_p6398    v_p6398    w_p6398  u_p6399  v_p6399  w_p6399  \n",
+       "k   2.000000   0.000000   1.000000   2.000000      0.0      1.0      2.0  \n",
+       "x   0.000000   0.000000   0.000000   0.000000      0.0      0.0      0.0  \n",
+       "y  10.000000  10.000000  10.000000  10.000000     10.0     10.0     10.0  \n",
+       "z  19.493671  19.746836  19.746836  19.746836     20.0     20.0     20.0  \n",
+       "\n",
+       "[4 rows x 19200 columns]"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# generate spatial gridpoints dataframe\n",
+    "ny = 80\n",
+    "nz = 80 #40\n",
+    "y = np.linspace(-10.0, 10.0, ny)\n",
+    "z = np.linspace(0.00001, 20.0, nz) \n",
+    "\n",
+    "spat_df = gen_spat_grid(y, z)  # if `comps` not passed in, assumes all 3 components are wanted\n",
+    "spat_df.head()  # look at the first few rows"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e3451a4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# generate time vector\n",
+    "t_final = 1.0 #10.0 [s]\n",
+    "dt = 0.01 # [s]\n",
+    "t_steps = int(t_final/dt)\n",
+    "time = np.linspace(0, t_final, t_steps)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c054149",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>u_p0</th>\n",
+       "      <th>v_p0</th>\n",
+       "      <th>w_p0</th>\n",
+       "      <th>u_p1</th>\n",
+       "      <th>v_p1</th>\n",
+       "      <th>w_p1</th>\n",
+       "      <th>u_p2</th>\n",
+       "      <th>v_p2</th>\n",
+       "      <th>w_p2</th>\n",
+       "      <th>u_p3</th>\n",
+       "      <th>...</th>\n",
+       "      <th>w_p6396</th>\n",
+       "      <th>u_p6397</th>\n",
+       "      <th>v_p6397</th>\n",
+       "      <th>w_p6397</th>\n",
+       "      <th>u_p6398</th>\n",
+       "      <th>v_p6398</th>\n",
+       "      <th>w_p6398</th>\n",
+       "      <th>u_p6399</th>\n",
+       "      <th>v_p6399</th>\n",
+       "      <th>w_p6399</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0.0</th>\n",
+       "      <td>4.546573</td>\n",
+       "      <td>3.142915</td>\n",
+       "      <td>0.736270</td>\n",
+       "      <td>9.174638</td>\n",
+       "      <td>-3.407159</td>\n",
+       "      <td>-0.739441</td>\n",
+       "      <td>7.627906</td>\n",
+       "      <td>-3.949300</td>\n",
+       "      <td>2.174219</td>\n",
+       "      <td>9.618385</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-0.780821</td>\n",
+       "      <td>8.690532</td>\n",
+       "      <td>-0.883842</td>\n",
+       "      <td>1.501049</td>\n",
+       "      <td>12.613932</td>\n",
+       "      <td>-1.490979</td>\n",
+       "      <td>2.045499</td>\n",
+       "      <td>11.442407</td>\n",
+       "      <td>3.464743</td>\n",
+       "      <td>-0.955902</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.2</th>\n",
+       "      <td>1.346335</td>\n",
+       "      <td>-2.955881</td>\n",
+       "      <td>2.169058</td>\n",
+       "      <td>8.483731</td>\n",
+       "      <td>-0.467436</td>\n",
+       "      <td>-2.390213</td>\n",
+       "      <td>11.691883</td>\n",
+       "      <td>-1.226122</td>\n",
+       "      <td>-0.564967</td>\n",
+       "      <td>11.852898</td>\n",
+       "      <td>...</td>\n",
+       "      <td>-2.532348</td>\n",
+       "      <td>16.119475</td>\n",
+       "      <td>2.127803</td>\n",
+       "      <td>0.958641</td>\n",
+       "      <td>16.669781</td>\n",
+       "      <td>-1.088475</td>\n",
+       "      <td>-1.376993</td>\n",
+       "      <td>19.397046</td>\n",
+       "      <td>1.917844</td>\n",
+       "      <td>1.193458</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.4</th>\n",
+       "      <td>-4.374607</td>\n",
+       "      <td>-0.072106</td>\n",
+       "      <td>-2.333083</td>\n",
+       "      <td>-0.173011</td>\n",
+       "      <td>-1.267879</td>\n",
+       "      <td>1.941986</td>\n",
+       "      <td>2.583170</td>\n",
+       "      <td>1.713110</td>\n",
+       "      <td>-2.255706</td>\n",
+       "      <td>4.476730</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.450413</td>\n",
+       "      <td>16.885632</td>\n",
+       "      <td>1.467120</td>\n",
+       "      <td>-2.732148</td>\n",
+       "      <td>19.200120</td>\n",
+       "      <td>-2.911494</td>\n",
+       "      <td>-1.975244</td>\n",
+       "      <td>19.242093</td>\n",
+       "      <td>-3.068319</td>\n",
+       "      <td>0.809181</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.6</th>\n",
+       "      <td>2.247058</td>\n",
+       "      <td>-2.200348</td>\n",
+       "      <td>-0.355774</td>\n",
+       "      <td>5.464088</td>\n",
+       "      <td>1.811769</td>\n",
+       "      <td>0.341703</td>\n",
+       "      <td>5.455402</td>\n",
+       "      <td>0.787239</td>\n",
+       "      <td>0.833149</td>\n",
+       "      <td>2.860843</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.966887</td>\n",
+       "      <td>18.651631</td>\n",
+       "      <td>1.531907</td>\n",
+       "      <td>-0.171771</td>\n",
+       "      <td>14.085346</td>\n",
+       "      <td>2.093165</td>\n",
+       "      <td>0.771838</td>\n",
+       "      <td>13.467859</td>\n",
+       "      <td>-1.023364</td>\n",
+       "      <td>1.390126</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0.8</th>\n",
+       "      <td>0.300492</td>\n",
+       "      <td>2.085420</td>\n",
+       "      <td>-0.216471</td>\n",
+       "      <td>7.941804</td>\n",
+       "      <td>3.330706</td>\n",
+       "      <td>0.845965</td>\n",
+       "      <td>8.126225</td>\n",
+       "      <td>2.675073</td>\n",
+       "      <td>-0.186695</td>\n",
+       "      <td>9.673127</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.895869</td>\n",
+       "      <td>13.295519</td>\n",
+       "      <td>-4.242989</td>\n",
+       "      <td>0.444229</td>\n",
+       "      <td>11.263903</td>\n",
+       "      <td>3.397782</td>\n",
+       "      <td>0.534900</td>\n",
+       "      <td>10.472029</td>\n",
+       "      <td>-1.290904</td>\n",
+       "      <td>-2.436863</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 19200 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         u_p0      v_p0      w_p0      u_p1      v_p1      w_p1       u_p2  \\\n",
+       "0.0  4.546573  3.142915  0.736270  9.174638 -3.407159 -0.739441   7.627906   \n",
+       "0.2  1.346335 -2.955881  2.169058  8.483731 -0.467436 -2.390213  11.691883   \n",
+       "0.4 -4.374607 -0.072106 -2.333083 -0.173011 -1.267879  1.941986   2.583170   \n",
+       "0.6  2.247058 -2.200348 -0.355774  5.464088  1.811769  0.341703   5.455402   \n",
+       "0.8  0.300492  2.085420 -0.216471  7.941804  3.330706  0.845965   8.126225   \n",
+       "\n",
+       "         v_p2      w_p2       u_p3  ...   w_p6396    u_p6397   v_p6397  \\\n",
+       "0.0 -3.949300  2.174219   9.618385  ... -0.780821   8.690532 -0.883842   \n",
+       "0.2 -1.226122 -0.564967  11.852898  ... -2.532348  16.119475  2.127803   \n",
+       "0.4  1.713110 -2.255706   4.476730  ...  1.450413  16.885632  1.467120   \n",
+       "0.6  0.787239  0.833149   2.860843  ...  0.966887  18.651631  1.531907   \n",
+       "0.8  2.675073 -0.186695   9.673127  ...  0.895869  13.295519 -4.242989   \n",
+       "\n",
+       "      w_p6397    u_p6398   v_p6398   w_p6398    u_p6399   v_p6399   w_p6399  \n",
+       "0.0  1.501049  12.613932 -1.490979  2.045499  11.442407  3.464743 -0.955902  \n",
+       "0.2  0.958641  16.669781 -1.088475 -1.376993  19.397046  1.917844  1.193458  \n",
+       "0.4 -2.732148  19.200120 -2.911494 -1.975244  19.242093 -3.068319  0.809181  \n",
+       "0.6 -0.171771  14.085346  2.093165  0.771838  13.467859 -1.023364  1.390126  \n",
+       "0.8  0.444229  11.263903  3.397782  0.534900  10.472029 -1.290904 -2.436863  \n",
+       "\n",
+       "[5 rows x 19200 columns]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# generate turbulent velocity flow field dataframe\n",
+    "# NOTE: This step can take up to 30 minutes\n",
+    "u_ref = 20\n",
+    "turb_df = gen_turb(spat_df, T=t_final, dt=dt, u_ref=u_ref)\n",
+    "turb_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "49854e83",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x1a131faf0>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# reshape to 3D array and visualize first timestep\n",
+    "data = {}\n",
+    "data['u'] = turb_df.filter(regex='u').values.reshape(len(turb_df),y.size,z.size).transpose((0, 2, 1))\n",
+    "data['v'] = turb_df.filter(regex='v').values.reshape(len(turb_df),y.size,z.size).transpose((0, 2, 1))\n",
+    "data['w'] = turb_df.filter(regex='w').values.reshape(len(turb_df),y.size,z.size).transpose((0, 2, 1))\n",
+    "\n",
+    "fig, ax = plt.subplots()\n",
+    "plt.imshow(data['u'][0,:,:],  # imshow requires nz-ny slice\n",
+    "            origin='lower',  # smallest y-z in lower left, not upper left\n",
+    "            extent=[y[0], y[-1], z[0], z[-1]],  # lateral and vertical limits\n",
+    "            interpolation='bilinear',\n",
+    "            cmap='coolwarm')  # image smoothing\n",
+    "plt.colorbar()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "860c590b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# write to h5 file\n",
+    "h5_filename = \"pct_turb_ny{}_nz{}_unconstrained_{}s_dt{}_uref{}.h5\".format(\n",
+    "    ny, nz, t_final, dt, u_ref\n",
+    ")\n",
+    "with h5py.File(\"../../input/\"+h5_filename, \"w\") as fp:\n",
+    "    fp.create_dataset(\"time_index\", shape=(t_steps,))\n",
+    "    fp[\"time_index\"][:] = time\n",
+    "    \n",
+    "    fp.create_dataset(\"y_coordinates\", shape=(ny,))\n",
+    "    fp[\"y_coordinates\"][:] = y\n",
+    "        \n",
+    "    fp.create_dataset(\"z_coordinates\", shape=(nz,))\n",
+    "    fp[\"z_coordinates\"][:] = z\n",
+    "        \n",
+    "    fp.create_dataset(\"u\", shape=(t_steps, nz, ny))\n",
+    "    fp[\"u\"][:] = data['u'][:]\n",
+    "    \n",
+    "    fp.create_dataset(\"v\", shape=(t_steps, nz, ny))\n",
+    "    fp[\"v\"][:] = data['v'][:]\n",
+    "    \n",
+    "    fp.create_dataset(\"w\", shape=(t_steps, nz, ny))\n",
+    "    fp[\"w\"][:] = data['w'][:]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26332012",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Top-level keys: ['time_index', 'u', 'v', 'w', 'y_coordinates', 'z_coordinates']\n",
+      "time_index -> <class 'h5py._hl.dataset.Dataset'>\n",
+      "u -> <class 'h5py._hl.dataset.Dataset'>\n",
+      "v -> <class 'h5py._hl.dataset.Dataset'>\n",
+      "w -> <class 'h5py._hl.dataset.Dataset'>\n",
+      "y_coordinates -> <class 'h5py._hl.dataset.Dataset'>\n",
+      "z_coordinates -> <class 'h5py._hl.dataset.Dataset'>\n",
+      "(100, 80, 80) float32\n"
+     ]
+    }
+   ],
+   "source": [
+    "# read h5 file\n",
+    "# Note: Replace the path below with the path on your local machine to the .h5 file that you want to read\n",
+    "fname = '/Users/bstanisl/Documents/repos/PVade/input/pct_turb_ny80_nz80_unconstrained_1.0s_dt0.01_uref20.h5'\n",
+    "\n",
+    "# Open the file (read-only)\n",
+    "with h5py.File(fname, \"r\") as f:\n",
+    "    # Explore the structure\n",
+    "    print(\"Top-level keys:\", list(f.keys()))\n",
+    "\n",
+    "    # print(f.visit(print))\n",
+    "\n",
+    "    # Recursively print structure and types\n",
+    "    def show_structure(name, obj):\n",
+    "        print(f\"{name} -> {type(obj)}\")\n",
+    "\n",
+    "    f.visititems(show_structure)\n",
+    "\n",
+    "    # Access a dataset\n",
+    "    data = f[\"u\"][:]\n",
+    "    print(data.shape, data.dtype)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pvade-pvlib",
+   "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.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/input/3d_cyld.yaml b/input/3d_cyld.yaml
index 32ad6386..8e56c2a6 100644
--- a/input/3d_cyld.yaml
+++ b/input/3d_cyld.yaml
@@ -11,26 +11,26 @@ domain:
   y_max: 0.41
   z_min: 0.0
   z_max: 0.41
-  l_char: 2.0 #.02
-pv_array:
-  stream_rows: 1 # not used
-  elevation: 1.5 # not used
-  stream_spacing: 7.0 # not used
-  panel_chord: 2.0 # not used
-  panel_span: 7.0 # not used
-  panel_thickness: 0.1 # not used
-  tracker_angle: 30.0 # not used
+  l_char: 5.0 #.02
+# pv_array:
+#   stream_rows: 1 # not used
+#   elevation: 1.5 # not used
+#   stream_spacing: 7.0 # not used
+#   panel_chord: 2.0 # not used
+#   panel_span: 7.0 # not used
+#   panel_thickness: 0.1 # not used
+#   tracker_angle: 30.0 # not used
 solver:
-  dt: 0.025
-  t_final: 0.1
-  solver1_ksp: cg
+  dt: 0.001
+  t_final: 0.01
+  solver1_ksp: gmres
   solver2_ksp: cg
   solver3_ksp: cg
   solver1_pc: jacobi
   solver2_pc: jacobi
   solver3_pc: jacobi
-  save_text_interval: 0.1
-  save_xdmf_interval: 0.1
+  save_text_interval: 0.001
+  save_xdmf_interval: 0.001
 fluid:
   velocity_profile_type: parabolic
   inflow_coeff: 16 # only necessary/used when applying a parabolic vel profile
diff --git a/input/duramat_case_study.yaml b/input/duramat_case_study.yaml
index 459c10b3..fb5939e9 100644
--- a/input/duramat_case_study.yaml
+++ b/input/duramat_case_study.yaml
@@ -37,7 +37,7 @@ solver:
   save_text_interval: 0.02
   save_xdmf_interval: 0.02
 fluid:
-  time_varying_inflow_window: 0.0
+  ramp_window: 0.0
   u_ref: 16.0
   rho: 1.0
   nu: 1.8e-05
diff --git a/input/flag2d.yaml b/input/flag2d.yaml
index 4312aa85..561a698e 100644
--- a/input/flag2d.yaml
+++ b/input/flag2d.yaml
@@ -34,7 +34,7 @@ fluid:
   velocity_profile_type: parabolic
   inflow_coeff: 6 # only necessary/used when applying a parabolic vel profile
   u_ref: 1.0 # 0.2 1.0 2.0
-  time_varying_inflow_window: 2.0
+  ramp_window: 2.0
   rho: 1000.0 # 0.2 1.0 2.0
   nu: 0.001 # Establish re = 20 with diam = 0.1 and u = u_ref
   dpdx: 0.0
diff --git a/input/heated_panels2d.yaml b/input/heated_panels2d.yaml
index a73abe9b..468634ff 100644
--- a/input/heated_panels2d.yaml
+++ b/input/heated_panels2d.yaml
@@ -14,6 +14,7 @@ domain:
   l_char: 0.1
 pv_array:
   stream_rows: 8
+  span_rows: 1
   elevation: 1.5
   stream_spacing: 5.0
   panel_chord: 2.0
@@ -35,7 +36,7 @@ solver:
   save_xdmf_interval: 0.01
 fluid:
   velocity_profile_type: uniform # loglaw
-  time_varying_inflow_window: 0.0
+  ramp_window: 0.0
   initialize_with_inflow_bc: true
   u_ref: 1.0
   nu: 0.001 #15.89e-5 #0.001
diff --git a/input/inflow_input.yaml b/input/inflow_input.yaml
index 7b384866..539e87f0 100644
--- a/input/inflow_input.yaml
+++ b/input/inflow_input.yaml
@@ -24,7 +24,7 @@ solver:
   solver1_ksp: gmres
   solver2_ksp: gmres
   solver3_ksp: gmres
-  solver4_ksp: gmres
+  # solver4_ksp: gmres
   solver1_pc: hypre
   solver2_pc: hypre
   solver3_pc: hypre
@@ -37,7 +37,7 @@ fluid:
   u_ref: 4.0 # 0.2 1.0 2.0
   z0: 0.005 #m
   d0: 0.05 #m
-  time_varying_inflow_window: 0.0
+  ramp_window: 0.0
   initialize_with_inflow_bc: true
   rho: 1000.0 # 0.2 1.0 2.0
   nu: 0.001 # Establish re = 20 with diam = 0.1 and u = u_ref
diff --git a/input/panels2d.yaml b/input/panels2d.yaml
index cee63d41..7482b212 100644
--- a/input/panels2d.yaml
+++ b/input/panels2d.yaml
@@ -9,9 +9,10 @@ domain:
   x_max: 50
   y_min: 0
   y_max: 20
-  l_char: 0.9
+  l_char: 0.5
 pv_array:
   stream_rows: 1
+  span_rows: 1
   elevation: 1.5
   stream_spacing: 7.0
   panel_chord: 2.0
diff --git a/input/panels3d.yaml b/input/panels3d.yaml
index 93e4004b..a66e1c53 100644
--- a/input/panels3d.yaml
+++ b/input/panels3d.yaml
@@ -39,6 +39,7 @@ solver:
   save_text_interval: .1 #0.01
   save_xdmf_interval: .1 #0.01
 fluid:
+  velocity_profile_type: uniform
   u_ref: 1.0
   nu: 0.01
   turbulence_model:  smagorinsky #null #  
@@ -56,4 +57,4 @@ structure:
   body_force_y: 0
   body_force_z: -1 #100
   bc_list: [left ]
-  tube_connection: False
\ No newline at end of file
+  tube_connection: False
diff --git a/input/pct_turb_ny80_nz80_unconstrained_1.0s_dt0.01_uref20.h5 b/input/pct_turb_ny80_nz80_unconstrained_1.0s_dt0.01_uref20.h5
new file mode 100644
index 00000000..9d814c15
Binary files /dev/null and b/input/pct_turb_ny80_nz80_unconstrained_1.0s_dt0.01_uref20.h5 differ
diff --git a/input/single_heliostat.yaml b/input/single_heliostat.yaml
index 7bb4c39c..df74175c 100644
--- a/input/single_heliostat.yaml
+++ b/input/single_heliostat.yaml
@@ -11,7 +11,7 @@ domain:
   y_max: 20 # 20+39 39 is panel to panel 
   z_min: 0
   z_max: 40
-  l_char: 1.25 # 1.0
+  l_char: 4 #1.25 # 1.0
 pv_array:
   stream_rows: 1
   elevation: 5.5
@@ -38,7 +38,6 @@ solver:
   save_text_interval: .02 #0.01
   save_xdmf_interval: .02 #0.01
 fluid:
-  time_varying_inflow_bc: false # true
   u_ref: 2.0
   rho: 1.0
   nu: 1.8e-05
diff --git a/input/test_heatedpanels2d.yaml b/input/test_heatedpanels2d.yaml
deleted file mode 100644
index 1219793e..00000000
--- a/input/test_heatedpanels2d.yaml
+++ /dev/null
@@ -1,73 +0,0 @@
-general:
-  geometry_module: panels2d
-  output_dir: output/test_heatedpanels2d
-  mesh_only: false
-  structural_analysis: True
-  fluid_analysis: True
-  thermal_analysis: True
-  debug_flag: True
-domain:
-  x_min: -0.3
-  x_max: 1.0 #0.7 #1.0 # 50
-  y_min: 0
-  y_max: 0.4 # 20
-  l_char: 0.006 #83 #0.9
-pv_array:
-  stream_rows: 3
-  elevation: 0.15
-  stream_spacing: 0.2 #
-  panel_chord: 0.1 # 2.0
-  panel_span: 7.0
-  panel_thickness: 0.03 # 0.1
-  tracker_angle: 30. #30.0
-solver:
-  dt: .01 # .001
-  t_final: 2.0
-  solver1_ksp: gmres
-  solver2_ksp: cg
-  solver3_ksp: cg
-  solver4_ksp: gmres
-  solver1_pc: jacobi
-  solver2_pc: jacobi
-  solver3_pc: jacobi
-  solver4_pc: lu
-  save_text_interval: 0.01 # must be same as or bigger than dt
-  save_xdmf_interval: 0.01
-fluid:
-  velocity_profile_type: uniform # loglaw
-  u_ref: 0.5 # 0.2 1.0 2.0
-  z0: 0.005 #m
-  d0: 0.05 #m
-  time_varying_inflow_window: 0.0
-  initialize_with_inflow_bc: true
-  # u_ref: 0.5 #0.5
-  nu: 15.89e-5 #0.001
-  g: 9.81
-  beta: 0.00333
-  alpha: 2.25e-05 # high Pe # 0.00225 # low Pe (no stability needed) # 
-  turbulence_model: 
-  periodic: false 
-  bc_y_max: slip # slip noslip free
-  bc_y_min: noslip # slip noslip free
-  T_ambient: 300.0
-  T_bottom: 320.0
-  T0_panel: 340.0
-structure:
-    dt : .01 # 0.002
-    # rho : 10000.0
-    # rho : 10000.0 # 10000.0
-    poissons_ratio: 0.3
-    elasticity_modulus: 1.0e+05
-    body_force_x: 0
-    body_force_y: -1
-    body_force_z: 0 #100
-    bc_list: ["top"]
-    motor_connection: False
-    tube_connection: False
-    beta_relaxation: 0.005
-
-    # elasticity_modulus: 1.0e+09
-    # poissons_ratio: 0.3
-    # body_force_x: 0
-    # body_force_y: 0
-    # bc_list: ["left"]
diff --git a/input/turbinflow_duramat_case_study.yaml b/input/turbinflow_duramat_case_study.yaml
new file mode 100644
index 00000000..f6ea68ac
--- /dev/null
+++ b/input/turbinflow_duramat_case_study.yaml
@@ -0,0 +1,62 @@
+general:
+  geometry_module: panels3d
+  output_dir: output/turbinflow_duramat_case_study
+  mesh_only: false
+  structural_analysis: true
+  fluid_analysis: true
+domain:
+  x_min: -20.0
+  x_max: 60.0
+  y_min: -10.0
+  y_max: 10.0
+  z_min: 0.0
+  z_max: 20.0
+  l_char: 1.25
+pv_array:
+  stream_rows: 1
+  stream_spacing: 10.0
+  span_rows: 1
+  span_spacing: 30.0
+  panel_chord: 4.1
+  panel_span: 10.0
+  panel_thickness: 0.1
+  elevation: 2.1
+  tracker_angle: 0.0
+  span_fixation_pts: [13.2]
+solver:
+  dt: 0.02
+  t_final: 1.0 #20.0
+  solver1_ksp: gmres
+  solver2_ksp: gmres
+  solver3_ksp: gmres
+  solver5_ksp: gmres
+  solver1_pc: hypre
+  solver2_pc: hypre
+  solver3_pc: hypre
+  solver5_pc: hypre
+  save_text_interval: 0.02
+  save_xdmf_interval: 0.02
+fluid:
+  velocity_profile_type: specified_from_file
+  h5_filename: input/pct_turb_ny80_nz80_unconstrained_1.0s_dt0.01_uref20.h5
+  initialize_with_inflow_bc: true
+  rho: 1.0
+  nu: 1.8e-05
+  turbulence_model: smagorinsky
+  bc_y_max: slip
+  bc_y_min: slip
+  bc_z_max: slip
+  bc_z_min: noslip
+  wind_direction: 270.0
+structure:
+  dt : 0.02
+  rho: 124.0
+  poissons_ratio: 0.3
+  elasticity_modulus: 4.0e+09
+  body_force_x: 0.0
+  body_force_y: 0.0
+  body_force_z: 0.0
+  bc_list: []
+  motor_connection: true
+  tube_connection: true
+  beta_relaxation: 0.5
\ No newline at end of file
diff --git a/pvade/IO/DataStream.py b/pvade/IO/DataStream.py
index 2c158b61..d602af7a 100644
--- a/pvade/IO/DataStream.py
+++ b/pvade/IO/DataStream.py
@@ -1,22 +1,69 @@
-# from dolfinx import *
-import numpy as np
-import time
-import os
-import shutil
-from dolfinx.io import XDMFFile, VTKFile
-from mpi4py import MPI
-from pathlib import Path
-import pytest
 import dolfinx
-from petsc4py import PETSc
-import json
+import ufl
+import sys
+
+import numpy as np
+
+from datetime import datetime
 
 # from dolfinx.fem import create_nonmatching_meshes_interpolation_data
+# import logging
+
+
+def start_print_and_log(rank, logfile_name):
+
+    class PrintAndLog:
+        """
+        A class to capture normal print statements in a log file
+        along with displaying them to the terminal as usual.
+        """
+
+        def __init__(self, logfile_name, rank, message_type):
+            self.logfile_name = logfile_name
+            self.rank = rank
+            self.message_type = message_type
+
+            if message_type == "INFO":
+                self.terminal = sys.__stdout__
+            elif message_type == "ERROR":
+                self.terminal = sys.__stdout__
+            else:
+                raise ValueError(f"Type {message_type} not recognized")
+
+        def write(self, message):
+            # Write to both the command line and save to the logfile
+            cleaned_message = message.rstrip()
+
+            # Can include a test like `len(message) > 0 and self.rank == 0`
+            # to limit this to only printing from rank 0, but for parallel
+            # debugging, it is often helpful to see messages from all ranks
+            # so we omit this check for now.
+            if len(cleaned_message) > 0:
+
+                cleaned_message += "\n"
+
+                self.terminal.write(f"{cleaned_message}")
+                timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
-# hello
+                with open(self.logfile_name, "a") as fp:
+                    fp.write(f"{timestamp} [{self.message_type}] {cleaned_message}")
+
+        def flush(self):
+            # Dummy method
+            pass
+
+    with open(logfile_name, "w") as fp:
+        # Start with an empty file
+        pass
+
+    # Redirect stdout and stderr
+    sys.stdout = PrintAndLog(logfile_name, rank, message_type="INFO")
+    sys.stderr = PrintAndLog(logfile_name, rank, message_type="ERROR")
+
+    if rank == 0:
+        print("Starting PVade Run")
 
 
-# test actions
 class DataStream:
     """Input/Output and file writing class
 
@@ -32,7 +79,7 @@ class DataStream:
 
     """
 
-    def __init__(self, domain, flow, structure, params):
+    def __init__(self, domain, flow, structure=None, params=None):
         """Initialize the DataStream object
 
         This initializes an object that manages the I/O for all of PVade.
@@ -50,18 +97,15 @@ def __init__(self, domain, flow, structure, params):
         self.ndim = domain.fluid.msh.topology.dim
         self.thermal_analysis = params.general.thermal_analysis
 
-        self.log_filename = f"{params.general.output_dir_sol}/log.txt"
-        if self.rank == 0:
-            with open(self.log_filename, "w") as fp:
-                fp.write("Run Started.\n")
-
         # If doing a fluid simulation, start a fluid solution file
         if params.general.fluid_analysis:
             self.results_filename_fluid = (
                 f"{params.general.output_dir_sol}/solution_fluid.xdmf"
             )
 
-            with XDMFFile(self.comm, self.results_filename_fluid, "w") as xdmf_file:
+            with dolfinx.io.XDMFFile(
+                self.comm, self.results_filename_fluid, "w"
+            ) as xdmf_file:
                 tt = 0.0
                 xdmf_file.write_mesh(domain.fluid.msh)
                 xdmf_file.write_function(flow.u_k, 0.0)
@@ -78,13 +122,31 @@ def __init__(self, domain, flow, structure, params):
                 f"{params.general.output_dir_sol}/solution_structure.xdmf"
             )
 
-            with XDMFFile(self.comm, self.results_filename_structure, "w") as xdmf_file:
+            # Since this is the first call, build solvers that project forms on an as-saved basis
+            # Set up the linear problem used for the projection, cg solver and jacobi pc
+            petsc_options = {"ksp_type": "cg", "pc_type": "jacobi"}
+            self.prob_k_nominal = dolfinx.fem.petsc.LinearProblem(
+                ufl.lhs(structure.elasticity.k_nominal_proj),
+                ufl.rhs(structure.elasticity.k_nominal_proj),
+                bcs=[],
+                petsc_options=petsc_options,
+            )
+
+            # Solve for the stress tensor
+            sol_k_nominal = self.prob_k_nominal.solve()
+            structure.elasticity.internal_stress.x.array[:] = sol_k_nominal.x.array[:]
+            structure.elasticity.internal_stress.x.scatter_forward()
+
+            with dolfinx.io.XDMFFile(
+                self.comm, self.results_filename_structure, "w"
+            ) as xdmf_file:
                 tt = 0.0
                 xdmf_file.write_mesh(domain.structure.msh)
                 xdmf_file.write_function(structure.elasticity.u, 0.0)
-                xdmf_file.write_function(structure.elasticity.stress, 0.0)
                 xdmf_file.write_function(structure.elasticity.v_old, 0.0)
-                xdmf_file.write_function(structure.elasticity.sigma_vm_h, 0.0)
+                xdmf_file.write_function(structure.elasticity.a_old, 0.0)
+                xdmf_file.write_function(structure.elasticity.stress, 0.0)
+                xdmf_file.write_function(structure.elasticity.internal_stress, 0.0)
 
         if self.comm.rank == 0 and self.comm.size > 1 and params.general.test:
             self.log_filename_structure = f"{params.general.output_dir_sol}/log_str.txt"
@@ -151,7 +213,9 @@ def save_XDMF_files(self, fsi_object, domain, tt):
         """
 
         if fsi_object.name == "fluid":
-            with XDMFFile(self.comm, self.results_filename_fluid, "a") as xdmf_file:
+            with dolfinx.io.XDMFFile(
+                self.comm, self.results_filename_fluid, "a"
+            ) as xdmf_file:
                 xdmf_file.write_function(fsi_object.u_k, tt)
                 xdmf_file.write_function(fsi_object.p_k, tt)
                 xdmf_file.write_function(fsi_object.panel_stress, tt)
@@ -160,24 +224,25 @@ def save_XDMF_files(self, fsi_object, domain, tt):
                     xdmf_file.write_function(fsi_object.theta_k, tt)
 
         elif fsi_object.name == "structure":
-            with XDMFFile(self.comm, self.results_filename_structure, "a") as xdmf_file:
+            # Solve for the stress tensor
+            sol_k_nominal = self.prob_k_nominal.solve()
+            fsi_object.elasticity.internal_stress.x.array[:] = sol_k_nominal.x.array[:]
+            fsi_object.elasticity.internal_stress.x.scatter_forward()
+
+            with dolfinx.io.XDMFFile(
+                self.comm, self.results_filename_structure, "a"
+            ) as xdmf_file:
                 xdmf_file.write_function(fsi_object.elasticity.u, tt)
-                xdmf_file.write_function(fsi_object.elasticity.stress, tt)
                 xdmf_file.write_function(fsi_object.elasticity.v_old, tt)
-                xdmf_file.write_function(fsi_object.elasticity.sigma_vm_h, tt)
+                xdmf_file.write_function(fsi_object.elasticity.a_old, tt)
+                xdmf_file.write_function(fsi_object.elasticity.stress, tt)
+                xdmf_file.write_function(fsi_object.elasticity.internal_stress, tt)
 
         else:
             raise ValueError(
                 f"Got found fsi object name = {fsi_object.name}, not recognized."
             )
 
-    def print_and_log(self, string_to_print):
-        if self.rank == 0:
-            print(string_to_print)
-
-            with open(self.log_filename, "a") as fp:
-                fp.write(f"{string_to_print}\n")
-
     # def fluid_struct(self, domain, flow, elasticity, params):
     #     # print("tst")
 
diff --git a/pvade/IO/Utilities.py b/pvade/IO/Utilities.py
index 413b95a3..250dbcfd 100644
--- a/pvade/IO/Utilities.py
+++ b/pvade/IO/Utilities.py
@@ -8,7 +8,7 @@ def get_input_file():
         "--input_file",
         metavar="",
         type=str,
-        help="The full path to the input file, e.g., 'intputs/my_params.yaml'",
+        help="The full path to the input file, e.g., 'inputs/my_params.yaml'",
     )
 
     command_line_inputs, unknown = parser.parse_known_args()
@@ -23,7 +23,7 @@ def get_input_file():
     return input_file_path
 
 
-def write_metrics(flow, elasticity, prof_filename="profiling.txt"):
+def write_metrics(flow, prof_filename="profiling.txt"):
     with open(prof_filename, "r") as output_file:
         if flow.fluid_analysis == True:
             # solver_line = [line for line in output_file if "(solve)" in line]
diff --git a/pvade/IO/input_schema.yaml b/pvade/IO/input_schema.yaml
index 9f2892ab..4aefbfa4 100644
--- a/pvade/IO/input_schema.yaml
+++ b/pvade/IO/input_schema.yaml
@@ -118,15 +118,15 @@ properties:
     type: "object"
     properties:
       stream_rows:
-        default: 3
-        minimum: 1
+        default: 0
+        minimum: 0
         maximum: 10
         type: "integer"
         description: "The number of panel rows in the streamwise direction."
         units: "unitless"
       span_rows:
-        default: 1
-        minimum: 1
+        default: 0
+        minimum: 0
         maximum: 10
         type: "integer"
         description: "The number of panel rows in the spanwise direction."
@@ -233,6 +233,15 @@ properties:
         enum:
           - "cg"
           - "gmres"
+          - "bicg"
+          - "bicgstab"
+          - "minres"
+          - "preonly"
+          - "richardson"
+          - "chebyshev"
+          - "tfqmr"
+          - "pipecg"
+          - "pipegmres"
       solver2_ksp:
         default: "cg"
         type: "string"
@@ -240,6 +249,15 @@ properties:
         enum:
           - "cg"
           - "gmres"
+          - "bicg"
+          - "bicgstab"
+          - "minres"
+          - "preonly"
+          - "richardson"
+          - "chebyshev"
+          - "tfqmr"
+          - "pipecg"
+          - "pipegmres"
       solver3_ksp:
         default: "cg"
         type: "string"
@@ -247,55 +265,132 @@ properties:
         enum:
           - "cg"
           - "gmres"
+          - "bicg"
+          - "bicgstab"
+          - "minres"
+          - "preonly"
+          - "richardson"
+          - "chebyshev"
+          - "tfqmr"
+          - "pipecg"
+          - "pipegmres"
       solver4_ksp:
         default: "gmres"
         type: "string"
         description: "The solver to use for fluid solve 4 of 5"
         enum:
-          - "cg" # not tested
+          - "cg"
           - "gmres"
-          - "preonly" # for debugging
+          - "bicg"
+          - "bicgstab"
+          - "minres"
+          - "preonly"
+          - "richardson"
+          - "chebyshev"
+          - "tfqmr"
+          - "pipecg"
+          - "pipegmres"
       solver5_ksp:
         default: "cg"
         type: "string"
         description: "The solver to use for fluid solve 5 of 5"
         enum:
           - "cg"
-          - "gmres"    
+          - "gmres"
+          - "bicg"
+          - "bicgstab"
+          - "minres"
+          - "preonly"
+          - "richardson"
+          - "chebyshev"
+          - "tfqmr"
+          - "pipecg"
+          - "pipegmres" 
       solver1_pc:
         default: "hypre"
         type: "string"
         description: "The preconditioner to use for fluid solve 1 of 5"
         enum:
+          - "none"
           - "jacobi"
+          - "sor"
+          - "ilu"
+          - "icc"
+          - "asm"
+          - "gamg"
           - "hypre"
+          - "ml"
+          - "lu"
+          - "cholesky"
+          - "python"
       solver2_pc:
         default: "hypre"
         type: "string"
         description: "The preconditioner to use for fluid solve 2 of 5"
         enum:
+          - "none"
           - "jacobi"
+          - "sor"
+          - "ilu"
+          - "icc"
+          - "asm"
+          - "gamg"
           - "hypre"
+          - "ml"
+          - "lu"
+          - "cholesky"
+          - "python"
       solver3_pc:
         default: "hypre"
         type: "string"
         description: "The preconditioner to use for fluid solve 3 of 5"
         enum:
+          - "none"
           - "jacobi"
+          - "sor"
+          - "ilu"
+          - "icc"
+          - "asm"
+          - "gamg"
           - "hypre"
+          - "ml"
+          - "lu"
+          - "cholesky"
+          - "python"
       solver4_pc:
         default: "lu"
         type: "string"
         description: "The preconditioner to use for fluid solve 4 of 5"
         enum:
+          - "none"
+          - "jacobi"
+          - "sor"
+          - "ilu"
+          - "icc"
+          - "asm"
+          - "gamg"
+          - "hypre"
+          - "ml"
           - "lu"
+          - "cholesky"
+          - "python"
       solver5_pc:
         default: "hypre"
         type: "string"
         description: "The preconditioner to use for fluid solve 5 of 5"
         enum:
+          - "none"
           - "jacobi"
-          - "hypre"    
+          - "sor"
+          - "ilu"
+          - "icc"
+          - "asm"
+          - "gamg"
+          - "hypre"
+          - "ml"
+          - "lu"
+          - "cholesky"
+          - "python" 
   fluid:
     additionalProperties: false
     type: "object"
@@ -325,6 +420,7 @@ properties:
           - "uniform"
           - "loglaw"
           - "parabolic"
+          - "specified_from_file"
       inflow_coeff:
         default: 1.0
         minimum: 0.0
@@ -337,12 +433,12 @@ properties:
         minimum: 0.0
         maximum: 100.0
         type: "number"
-        description: "The velocity of the wind as measured at the panel elevation."
+        description: "The velocity of the wind as measured at the panel elevation. If `velocity_profile_type` == `specified_from_file`, this input u_ref value is not used and instead calculated in the simulation."
         units: "meter/second"
       z0:
         default: 0.05
         minimum: 0.001
-        maximum: 10.0
+        maximum: 0.1
         type: "number"
         description: "The surface roughness length used in the log law velocity profile."
         units: "meters"
@@ -353,15 +449,28 @@ properties:
         type: "number"
         description: "The zero plane displacement height used for the presence of vegetated or urban canopies in the log law velocity profile."
         units: "meters"
+      h5_filename:
+        default: null
+        type:
+          - "string"
+          - "null"
+        description: "The .h5 filename that specifies the inflow velocity boundary conditions."
+      psi:
+        default: 0.0
+        minimum: -10.0
+        maximum: 0.7
+        type: "number"
+        description: "Atmospheric stability correction function for log law: negative for unstable (convective, daytime) conditions, positive for stable (night-time) conditions, zero for neutral conditions."
+        units: "none"
       initialize_with_inflow_bc:
         default: true
         type: "boolean"
-        description: "If true, use the inflow boundary condition to interpolate a non-zero initial velocity throughout the domain (even if that does not respect interior boundary conditions), if false, initial velocity is zero."
-      time_varying_inflow_window:
+        description: "If true, use the inflow boundary condition to interpolate a non-zero initial velocity throughout the domain (even if that does not respect interior boundary conditions), if false, initial velocity is zero. If `velocity_profile_type` is `specified_from_file`, the velocity at each point is a time-averaged value of that gripoint's velocity data from the .h5 file."
+      ramp_window:
         default: 0.0
         minimum: 0.0
         type: "number"
-        description: "The amount of time over which the inflow condition should 'ramp up' to the full value of u_ref, smoothed using a cosine function. A value of 0 means the flow starts with inflow_vel = u_ref, values > 0 mean the flow starts at rest and smoothly increases until time = time_varying_inflow_window, where inflow_vel = u_ref."
+        description: "The amount of time over which the inflow condition should 'ramp up' to the full value of u_ref, smoothed using a cosine function. A value of 0 means the flow starts with inflow_vel = u_ref, values > 0 mean the flow starts at rest and smoothly increases until time = ramp_window, where inflow_vel = u_ref."
         units: "second"
       rho:
         default: 1.0
diff --git a/pvade/fluid/FlowManager.py b/pvade/fluid/FlowManager.py
index 5cd3f364..bd2c5c41 100644
--- a/pvade/fluid/FlowManager.py
+++ b/pvade/fluid/FlowManager.py
@@ -80,15 +80,32 @@ def __init__(self, domain, params):
 
             # find hmin in mesh
             num_cells = domain.fluid.msh.topology.index_map(self.ndim).size_local
+
             h = dolfinx.cpp.mesh.h(domain.fluid.msh, self.ndim, range(num_cells))
 
-            # This value of hmin is local to the mesh portion owned by the process
-            hmin_local = np.amin(h)
+            # # This value of hmin is local to the mesh portion owned by the process
+            # hmin_local = np.amin(h)
+
+            if len(h) > 0:
+                hmin_local = np.amin(h)
+            else:
+                hmin_local = np.inf
 
-            # collect the minimum hmin from all processes
+            print(hmin_local)
             self.hmin = np.zeros(1)
-            self.comm.Allreduce(hmin_local, self.hmin, op=MPI.MIN)
-            self.hmin = self.hmin[0]
+            self.hmin = self.comm.allreduce(hmin_local, op=MPI.MIN)
+
+            # ------------------------------------------------------------------------------
+
+            # h = dolfinx.cpp.mesh.h(domain.fluid.msh, self.ndim, range(num_cells))
+
+            # # This value of hmin is local to the mesh portion owned by the process
+            # hmin_local = np.amin(h)
+
+            # # collect the minimum hmin from all processes
+            # self.hmin = np.zeros(1)
+            # self.comm.Allreduce(hmin_local, self.hmin, op=MPI.MIN)
+            # self.hmin = self.hmin[0]
 
             self.num_Q_dofs = (
                 self.Q.dofmap.index_map_bs * self.Q.dofmap.index_map.size_global
@@ -98,7 +115,6 @@ def __init__(self, domain, params):
             )
 
             if self.rank == 0:
-                print(f"hmin on fluid  = {self.hmin}")
                 print(f"Total num dofs on fluid= {self.num_Q_dofs + self.num_V_dofs}")
 
     def build_boundary_conditions(self, domain, params):
@@ -174,9 +190,11 @@ def build_forms(self, domain, params):
             )  #  thermal diffusivity
 
             # Compute approximate Peclet number to assess if SUPG stabilization is needed
-            self.Pe_approx = (
-                params.fluid.u_ref * params.domain.l_char / (2.0 * params.fluid.alpha)
-            )
+            if params.fluid.velocity_profile_type == "specified_from_file":
+                u_ref = self.inflow_velocity.u_ref
+            else:
+                u_ref = params.fluid.u_ref
+            self.Pe_approx = u_ref * params.domain.l_char / (2.0 * params.fluid.alpha)
 
             if self.Pe_approx > 1.0:
                 self.stabilizing = True
@@ -234,6 +252,8 @@ def build_forms(self, domain, params):
             self.u_k2.interpolate(self.inflow_profile)
             self.u_k.interpolate(self.inflow_profile)
 
+            if self.rank == 0:
+                print("Initialized BC at the inlet")
             # print(min(abs(self.u_k.x.array[:] - self.inflow_profile.x.array[:])))
 
             # flags = []
@@ -688,15 +708,31 @@ def solve(self, domain, params, current_time):
             params (:obj:`pvade.Parameters.SimParams`): A SimParams object
         """
 
-        ramp_window = params.fluid.time_varying_inflow_window
+        ramp_window = params.fluid.ramp_window
+
+        if (ramp_window > 0.0 and current_time <= ramp_window) or (
+            params.fluid.velocity_profile_type == "specified_from_file"
+            and current_time <= self.inflow_velocity.inflow_t_final
+        ):
 
-        if ramp_window > 0.0 and current_time <= ramp_window:
             self.inflow_velocity.current_time = current_time
 
             if self.upper_cells is not None:
                 self.inflow_profile.interpolate(self.inflow_velocity, self.upper_cells)
             else:
                 self.inflow_profile.interpolate(self.inflow_velocity)
+            if self.rank == 0 and params.general.debug_flag:
+                print("applied inflow BC at current time: ", current_time)
+
+        if (
+            params.fluid.velocity_profile_type == "specified_from_file"
+            and current_time > self.inflow_velocity.inflow_t_final
+        ):
+
+            # kill the simulation (otherwise, the inflow BCs don't change, which isn't realistic)
+            raise ValueError(
+                f"No inflow data available at current time {current_time} s."
+            )
 
         if self.first_call_to_solver:
             if self.rank == 0:
@@ -734,7 +770,9 @@ def solve(self, domain, params, current_time):
 
         self.compute_lift_and_drag(params, current_time)
 
-        self.compute_pressure_drop_between_points(domain, params)
+        # Compute the pressure drop between the inlet and outlet
+        if params.pv_array.stream_rows > 0:
+            self.compute_pressure_drop_between_points(domain, params)
 
         # Update new -> old variables
         self.u_k2.x.array[:] = self.u_k1.x.array
@@ -946,11 +984,24 @@ def compute_cfl(self):
         self.solver_6.solve(self.b6, self.cfl_vec.vector)
         self.cfl_vec.x.scatter_forward()
 
-        cfl_max_local = np.amax(self.cfl_vec.vector.array)
+        # cfl_max_local = np.amax(self.cfl_vec.vector.array)
+
+        # # collect the minimum hmin from all processes
+        # self.cfl_max = np.zeros(1)
+        # self.comm.Allreduce(cfl_max_local, self.cfl_max, op=MPI.MAX)
+        # self.cfl_max = self.cfl_max[0]
+
+        # Compute local max only if array has values
+        if self.cfl_vec.vector.array.size > 0:
+            cfl_max_local = np.amax(self.cfl_vec.vector.array)
+        else:
+            cfl_max_local = -np.inf  # So it won't affect global max
 
-        # collect the minimum hmin from all processes
-        self.cfl_max = np.zeros(1)
-        self.comm.Allreduce(cfl_max_local, self.cfl_max, op=MPI.MAX)
+        # Prepare buffer and reduce across all ranks
+        self.cfl_max = np.zeros(1, dtype=np.float64)
+        self.comm.Allreduce(
+            np.array(cfl_max_local, dtype=np.float64), self.cfl_max, op=MPI.MAX
+        )
         self.cfl_max = self.cfl_max[0]
 
     def compute_lift_and_drag(self, params, current_time):
@@ -1014,6 +1065,17 @@ def compute_lift_and_drag(self, params, current_time):
 
                     fp.write("\n")
 
+            if params.fluid.velocity_profile_type == "specified_from_file":
+                u_ref = self.inflow_velocity.u_ref
+                if params.general.debug_flag == True:
+                    print(
+                        "using calc u_ref ({} m/s) instead of input/default u_ref ({} m/s)".format(
+                            self.inflow_velocity.u_ref, params.fluid.u_ref
+                        )
+                    )
+            else:
+                u_ref = params.fluid.u_ref
+
             with open(self.lift_and_drag_filename, "a") as fp:
                 fp.write(f"{current_time:.9e}")
 
@@ -1028,7 +1090,7 @@ def compute_lift_and_drag(self, params, current_time):
                         * fx
                         / (
                             params.fluid.rho
-                            * params.fluid.u_ref**2
+                            * u_ref**2
                             * params.pv_array.panel_chord
                             * params.pv_array.panel_span
                         )
@@ -1039,7 +1101,7 @@ def compute_lift_and_drag(self, params, current_time):
                         * fy
                         / (
                             params.fluid.rho
-                            * params.fluid.u_ref**2
+                            * u_ref**2
                             * params.pv_array.panel_chord
                             * params.pv_array.panel_span
                         )
@@ -1050,7 +1112,7 @@ def compute_lift_and_drag(self, params, current_time):
                         * fz
                         / (
                             params.fluid.rho
-                            * params.fluid.u_ref**2
+                            * u_ref**2
                             * params.pv_array.panel_chord
                             * params.pv_array.panel_span
                         )
diff --git a/pvade/fluid/boundary_conditions.py b/pvade/fluid/boundary_conditions.py
index 4de78772..a68b1533 100644
--- a/pvade/fluid/boundary_conditions.py
+++ b/pvade/fluid/boundary_conditions.py
@@ -2,6 +2,8 @@
 from petsc4py import PETSc
 
 import numpy as np
+import h5py
+import scipy.interpolate as interp
 
 import warnings
 
@@ -117,6 +119,48 @@ def __init__(self, ndim, params, current_time):
         self.params = params
         self.current_time = current_time
 
+        if self.params.fluid.velocity_profile_type == "specified_from_file":
+            with h5py.File(self.params.fluid.h5_filename, "r") as fp:
+                self.time_index = fp["time_index"][:]
+                self.y_coordinates = fp["y_coordinates"][:]
+                self.z_coordinates = fp["z_coordinates"][:]
+                self.u = fp["u"][:]
+                self.v = fp["v"][:]
+                self.w = fp["w"][:]
+
+            # Create the interpolators for the time-averaged values
+            x0_bar = (self.z_coordinates, self.y_coordinates)
+
+            self.interp_u_bar = interp.RegularGridInterpolator(
+                x0_bar, np.mean(self.u, axis=0), bounds_error=False, fill_value=None
+            )
+            self.interp_v_bar = interp.RegularGridInterpolator(
+                x0_bar, np.mean(self.v, axis=0), bounds_error=False, fill_value=None
+            )
+            self.interp_w_bar = interp.RegularGridInterpolator(
+                x0_bar, np.mean(self.w, axis=0), bounds_error=False, fill_value=None
+            )
+
+            # Create the known axes for our interpolators (t0, z0, y0) for instantaneous values
+            x0 = (self.time_index, self.z_coordinates, self.y_coordinates)
+
+            self.interp_u = interp.RegularGridInterpolator(
+                x0, self.u, bounds_error=False, fill_value=None
+            )
+            self.interp_v = interp.RegularGridInterpolator(
+                x0, self.v, bounds_error=False, fill_value=None
+            )
+            self.interp_w = interp.RegularGridInterpolator(
+                x0, self.w, bounds_error=False, fill_value=None
+            )
+
+            self.inflow_t_final = self.time_index[
+                -1
+            ]  # [s] time of last timestep of inflow file
+
+            # calculate u_ref from input .h5 file and apply
+            self.calculate_u_ref(params)
+
     def __call__(self, x):
         """Define an inflow expression for use as boundary condition
 
@@ -127,6 +171,7 @@ def __call__(self, x):
             np.ndarray: Value of velocity at each coordinate in input array
         """
 
+        # Preallocated velocity vector that we will fill
         inflow_values = np.zeros((self.ndim, x.shape[1]), dtype=PETSc.ScalarType)
 
         # if self.first_call_to_inflow_velocity:
@@ -138,7 +183,7 @@ def __call__(self, x):
         #     time_vary_u_ref goes from 0 -> u_ref smoothly over ramp_up_window time
         #     e.g., start velocity at 0, and by t=1.0 seconds, achieve full inflow speed
 
-        ramp_window = self.params.fluid.time_varying_inflow_window
+        ramp_window = self.params.fluid.ramp_window
 
         if ramp_window > 0.0 and self.current_time <= ramp_window:
             time_vary_u_ref = (
@@ -176,31 +221,91 @@ def __call__(self, x):
         elif self.params.fluid.velocity_profile_type == "loglaw":
             z0 = self.params.fluid.z0
             d0 = self.params.fluid.d0
+            psi = self.params.fluid.psi
             z_hub = self.params.pv_array.elevation
 
             # handle panels3d
             if self.ndim == 3:
                 inflow_values[0] = (
                     (time_vary_u_ref)
-                    * np.log(((x[2]) - d0) / z0)
-                    / (np.log((z_hub - d0) / z0))
+                    * (np.log(((x[2]) - d0) / z0) - psi)
+                    / (np.log((z_hub - d0) / z0) - psi)
                 )
 
             # handle panels2d
             elif self.ndim == 2:
                 # print("this is 2d")
                 inflow_values[0] = (
-                    (time_vary_u_ref)  # shouldn't this be u_star?
-                    * np.log(((x[1]) - d0) / z0)
-                    / (np.log((z_hub - d0) / z0))
+                    (time_vary_u_ref)
+                    * (np.log(((x[1]) - d0) / z0) - psi)
+                    / (np.log((z_hub - d0) / z0) - psi)
                 )
 
+        elif self.params.fluid.velocity_profile_type == "specified_from_file":
+
+            # only needed at time zero
+            if self.current_time == 0.0:
+                # These are the points over the entirety of the domain
+                xi_bulk = np.vstack((x[2], x[1])).T
+
+                u_vel_bar = self.interp_u_bar(
+                    xi_bulk
+                )  # this grabs u,v,w at current position
+                v_vel_bar = self.interp_v_bar(xi_bulk)
+                w_vel_bar = self.interp_w_bar(xi_bulk)
+
+                # Assign the mean inflow values
+                # Make this assignment everywhere *knowing* the masked point values will be overwritten
+                inflow_values[0, :] = u_vel_bar
+                inflow_values[1, :] = v_vel_bar
+                inflow_values[2, :] = w_vel_bar
+
+            # assuming always a timeseries for now
+            xi_0_mask = x[0] < self.params.domain.x_min + 1e-5
+            ti = self.current_time * np.ones(np.sum(xi_0_mask))
+
+            # These are the points that define the inflow plane only
+            xi = np.vstack((ti, x[2][xi_0_mask], x[1][xi_0_mask])).T
+
+            u_vel = self.interp_u(xi)  # this grabs u,v,w at current time and at x inlet
+            v_vel = self.interp_v(xi)
+            w_vel = self.interp_w(xi)
+
+            # Assign the turbulent values (from the interpolator+file) to the masked inflow plane
+            # this will overwrite the previously-assigned averaged values
+            inflow_values[0, xi_0_mask] = u_vel
+            inflow_values[1, xi_0_mask] = v_vel
+            inflow_values[2, xi_0_mask] = w_vel
+
         # if self.first_call_to_inflow_velocity:
         #     print("inflow_values = ", inflow_values[0])
         #     self.first_call_to_inflow_velocity = False
 
         return inflow_values
 
+    def calculate_u_ref(self, params):
+        """Compute time-averaged inflow profile from file
+
+        Outputs:
+            u_ref : effective u_ref computed from input inflow file - velocity at panel elevation
+            u_inf : streamwise velocity in freestream (at highest elevation in domain)
+            z0
+        """
+
+        # TODO - add handling for 2D case
+
+        # compute the magnitude to account for other wind directions
+        umag = (self.u**2 + self.v**2) ** 0.5
+        umag_mean = np.average(
+            np.average(umag, axis=0), axis=-1
+        )  # vertical profile (averaged in time and y)
+
+        # extract u_ref at elevation height
+        z_idx = np.argmin(abs(self.z_coordinates - params.pv_array.elevation))
+        u_ref_calc = umag_mean[z_idx]
+
+        self.u_ref = u_ref_calc
+
 
 def get_inflow_profile_function(domain, params, functionspace, current_time):
     ndim = domain.ndim
@@ -265,6 +370,22 @@ def get_inflow_profile_function(domain, params, functionspace, current_time):
 
         inflow_function.interpolate(inflow_velocity, upper_cells)
 
+    elif params.fluid.velocity_profile_type == "specified_from_file":
+        if domain.rank == 0:
+            print("Setting inflow velocity from {}".format(params.fluid.h5_filename))
+            if params.general.debug_flag:
+                print("eff u_ref = {} m/s".format(inflow_velocity.u_ref))
+        inflow_function.interpolate(inflow_velocity)
+
+        if params.solver.t_final > inflow_velocity.inflow_t_final:
+            if domain.rank == 0:
+                print(
+                    "WARNING: t_final ({:.2f} s) exceeds the final time in input inflow velocity file ({:.2f} s). "
+                    "Simulation will fail at that point.".format(
+                        params.solver.t_final, inflow_velocity.inflow_t_final
+                    )
+                )
+
     return inflow_function, inflow_velocity, upper_cells
 
 
@@ -308,8 +429,8 @@ def build_velocity_boundary_conditions(domain, params, functionspace, current_ti
         domain, params, functionspace, current_time
     )
 
-    if domain.rank == 0:
-        print("inflow_function = ", inflow_function.x.array[:])
+    # if domain.rank == 0:
+    #     print("inflow_function = ", inflow_function.x.array[:])
 
     dofs = get_facet_dofs_by_gmsh_tag(domain, functionspace, "x_min")
     bcu.append(dolfinx.fem.dirichletbc(inflow_function, dofs))
diff --git a/pvade/geometry/MeshManager.py b/pvade/geometry/MeshManager.py
index be30aab3..13f1764d 100644
--- a/pvade/geometry/MeshManager.py
+++ b/pvade/geometry/MeshManager.py
@@ -214,15 +214,17 @@ def build(self, params):
         self.cell_tags.name = "cell_tags"
         self.facet_tags.name = "facet_tags"
 
-        if (
-            params.general.geometry_module == "panels3d"
-            or params.general.geometry_module == "heliostats3d"
-            or params.general.geometry_module == "flag2d"
-            or params.general.geometry_module == "panels2d"
-        ):
-            self._create_submeshes_from_parent(params)
-            self._transfer_mesh_tags_to_submeshes(params)
-
+        # if (
+        #     params.general.geometry_module == "panels3d"
+        #     or params.general.geometry_module == "heliostats3d"
+        #     or params.general.geometry_module == "flag2d"
+        #     or params.general.geometry_module == "panels2d"
+        # ):
+        #     self._create_submeshes_from_parent(params)
+        #     self._transfer_mesh_tags_to_submeshes(params)
+
+        self._create_submeshes_from_parent(params)
+        self._transfer_mesh_tags_to_submeshes(params)
         self._save_submeshes_for_reload_hack(params)
 
         if params.general.fluid_analysis == True:
@@ -253,67 +255,6 @@ def _save_submeshes_for_reload_hack(self, params):
         self.write_mesh_files(params)
         self.read_mesh_files(params.general.output_dir_mesh, params)
 
-        # if params.general.fluid_analysis == True and params.general.structural_analysis == True :
-        #     sub_domain_list = ["fluid", "structure"]
-        #     for sub_domain_name in sub_domain_list:
-        #         mesh_filename = os.path.join(params.general.output_dir_mesh, f"temp_{sub_domain_name}.xdmf")
-        #         sub_domain = getattr(self, sub_domain_name)
-        #         sub_domain.msh.name = "temp_mesh"
-
-        #         # Write this submesh to immediately read it
-        #         with dolfinx.io.XDMFFile(self.comm, mesh_filename, "w") as xdmf:
-        #             xdmf.write_mesh(sub_domain.msh)
-        #             xdmf.write_meshtags(sub_domain.cell_tags)
-        #             sub_domain.msh.topology.create_connectivity(self.ndim-1, self.ndim)
-        #             xdmf.write_meshtags(sub_domain.facet_tags)
-
-        #         # Read the just-written mesh
-        #         with dolfinx.io.XDMFFile(self.comm, mesh_filename, "r") as xdmf:
-        #             submesh = xdmf.read_mesh(name=sub_domain.msh.name)
-        #             cell_tags = xdmf.read_meshtags(submesh, name="cell_tags")
-        #             ndim = submesh.topology.dim
-        #             submesh.topology.create_connectivity(ndim - 1, ndim)
-        #             facet_tags = xdmf.read_meshtags(submesh, name="facet_tags")
-
-        #         sub_domain.msh = submesh
-        #         sub_domain.facet_tags = facet_tags
-        #         sub_domain.cell_tags = cell_tags
-
-        # elif params.general.geometry_module == "panels3d" and params.general.fluid_analysis == False and params.general.structural_analysis == True :
-        #         sub_domain_name = "structure"
-
-        #         mesh_filename = os.path.join(params.general.output_dir_mesh, f"temp_{sub_domain_name}.xdmf")
-        #         # sub_domain = getattr(self, sub_domain_list[0])
-        #         # sub_domain.msh.name = "temp_mesh"
-
-        #         # self.msh.name  = "temp_mesh"
-
-        #         # Write this submesh to immediately read it
-        #         with dolfinx.io.XDMFFile(self.comm, mesh_filename, "w") as xdmf:
-        #             xdmf.write_mesh(self.msh)
-        #             xdmf.write_meshtags(self.cell_tags)
-        #             self.msh.topology.create_connectivity(self.ndim-1, self.ndim)
-        #             xdmf.write_meshtags(self.facet_tags)
-
-        #         # Read the just-written mesh
-        #         with dolfinx.io.XDMFFile(self.comm, mesh_filename, "r") as xdmf:
-        #             mesh = xdmf.read_mesh(name=self.msh.name)
-        #             cell_tags = xdmf.read_meshtags(mesh, name="cell_tags")
-        #             ndim = mesh.topology.dim
-        #             mesh.topology.create_connectivity(ndim - 1, ndim)
-        #             facet_tags = xdmf.read_meshtags(mesh, name="facet_tags")
-
-        #         class FSISubDomain:
-        #             pass
-
-        #         sub_domain = FSISubDomain()
-
-        #         sub_domain.msh = mesh
-        #         sub_domain.facet_tags = facet_tags
-        #         sub_domain.cell_tags = cell_tags
-
-        #         setattr(self, sub_domain_name, sub_domain)
-
     def _create_submeshes_from_parent(self, params):
         """Create submeshes from a parent mesh by cell tags.
 
@@ -620,86 +561,92 @@ def read_mesh_files(self, read_mesh_dir, params):
             mesh_name = f"{sub_domain_name}_mesh.xdmf"
             mesh_filename = os.path.join(read_mesh_dir, mesh_name)
 
-            try:
-                if self.rank == 0:
-                    print(f"Reading {sub_domain_name} mesh.")
-
-                # Read the subdomain mesh
-                with dolfinx.io.XDMFFile(self.comm, mesh_filename, "r") as xdmf:
-                    submesh = xdmf.read_mesh(name=mesh_name)
-                    cell_tags = xdmf.read_meshtags(submesh, name="cell_tags")
-                    ndim = submesh.topology.dim
-                    submesh.topology.create_connectivity(ndim - 1, ndim)
-                    facet_tags = xdmf.read_meshtags(submesh, name="facet_tags")
-
-            except:
-                if self.rank == 0:
-                    print(
-                        f"Could not find subdomain {sub_domain_name} mesh file, not reading this mesh."
-                    )
+            if (
+                params.general.fluid_analysis == True
+                and sub_domain_name == "fluid"
+                or params.general.structural_analysis == True
+                and sub_domain_name == "structure"
+            ):
+                try:
+                    if self.rank == 0:
+                        print(f"Reading {sub_domain_name} mesh.")
+
+                    # Read the subdomain mesh
+                    with dolfinx.io.XDMFFile(self.comm, mesh_filename, "r") as xdmf:
+                        submesh = xdmf.read_mesh(name=mesh_name)
+                        cell_tags = xdmf.read_meshtags(submesh, name="cell_tags")
+                        ndim = submesh.topology.dim
+                        submesh.topology.create_connectivity(ndim - 1, ndim)
+                        facet_tags = xdmf.read_meshtags(submesh, name="facet_tags")
+
+                except:
+                    if self.rank == 0:
+                        print(
+                            f"Could not find subdomain {sub_domain_name} mesh file, not reading this mesh."
+                        )
 
-            else:
+                else:
 
-                class FSISubDomain:
-                    pass
+                    class FSISubDomain:
+                        pass
 
-                if self.ndim is None:
-                    self.ndim = submesh.topology.dim
-                else:
-                    assert self.ndim == submesh.topology.dim
+                    if self.ndim is None:
+                        self.ndim = submesh.topology.dim
+                    else:
+                        assert self.ndim == submesh.topology.dim
 
-                submesh.topology.create_connectivity(self.ndim, self.ndim - 1)
+                    submesh.topology.create_connectivity(self.ndim, self.ndim - 1)
 
-                sub_domain = FSISubDomain()
+                    sub_domain = FSISubDomain()
 
-                sub_domain.msh = submesh
-                sub_domain.cell_tags = cell_tags
-                sub_domain.facet_tags = facet_tags
+                    sub_domain.msh = submesh
+                    sub_domain.cell_tags = cell_tags
+                    sub_domain.facet_tags = facet_tags
 
-                # These elements do not need to be created when reading a mesh
-                # they are only used in the transfer of facet tags, and since
-                # those can be read directly from a file, we don't need these
-                sub_domain.entity_map = None
-                sub_domain.vertex_map = None
-                sub_domain.geom_map = None
+                    # These elements do not need to be created when reading a mesh
+                    # they are only used in the transfer of facet tags, and since
+                    # those can be read directly from a file, we don't need these
+                    sub_domain.entity_map = None
+                    sub_domain.vertex_map = None
+                    sub_domain.geom_map = None
 
-                setattr(self, sub_domain_name, sub_domain)
+                    setattr(self, sub_domain_name, sub_domain)
 
-                if sub_domain_name == "fluid":
-                    domain_ufl = ufl.Mesh(
-                        self.fluid.msh.ufl_domain().ufl_coordinate_element()
-                    )
-                    fluid_undeformed = dolfinx.mesh.Mesh(
-                        self.comm,
-                        self.fluid.msh.topology,
-                        self.fluid.msh.geometry,
-                        domain_ufl,
-                    )
+                    if sub_domain_name == "fluid":
+                        domain_ufl = ufl.Mesh(
+                            self.fluid.msh.ufl_domain().ufl_coordinate_element()
+                        )
+                        fluid_undeformed = dolfinx.mesh.Mesh(
+                            self.comm,
+                            self.fluid.msh.topology,
+                            self.fluid.msh.geometry,
+                            domain_ufl,
+                        )
 
-                    fluid_undeformed.topology.create_connectivity(
-                        self.ndim, self.ndim - 1
-                    )
+                        fluid_undeformed.topology.create_connectivity(
+                            self.ndim, self.ndim - 1
+                        )
 
-                    sub_domain_undeformed = FSISubDomain()
+                        sub_domain_undeformed = FSISubDomain()
 
-                    sub_domain_undeformed.msh = fluid_undeformed
-                    sub_domain_undeformed.cell_tags = cell_tags
-                    sub_domain_undeformed.facet_tags = facet_tags
+                        sub_domain_undeformed.msh = fluid_undeformed
+                        sub_domain_undeformed.cell_tags = cell_tags
+                        sub_domain_undeformed.facet_tags = facet_tags
 
-                    # These elements do not need to be created when reading a mesh
-                    # they are only used in the transfer of facet tags, and since
-                    # those can be read directly from a file, we don't need these
-                    sub_domain_undeformed.entity_map = None
-                    sub_domain_undeformed.vertex_map = None
-                    sub_domain_undeformed.geom_map = None
+                        # These elements do not need to be created when reading a mesh
+                        # they are only used in the transfer of facet tags, and since
+                        # those can be read directly from a file, we don't need these
+                        sub_domain_undeformed.entity_map = None
+                        sub_domain_undeformed.vertex_map = None
+                        sub_domain_undeformed.geom_map = None
 
-                    setattr(self, "fluid_undeformed", sub_domain_undeformed)
+                        setattr(self, "fluid_undeformed", sub_domain_undeformed)
 
-                    # assert np.all(self.fluid.msh.geometry.x[:] == self.fluid_undeformed.msh.geometry.x[:])
-                    # assert np.shape(self.fluid.msh.geometry.x[:]) == np.shape(self.fluid_undeformed.msh.geometry.x[:])
+                        # assert np.all(self.fluid.msh.geometry.x[:] == self.fluid_undeformed.msh.geometry.x[:])
+                        # assert np.shape(self.fluid.msh.geometry.x[:]) == np.shape(self.fluid_undeformed.msh.geometry.x[:])
 
-            if self.rank == 0:
-                print(f"Finished read {sub_domain_name} mesh.")
+                if self.rank == 0:
+                    print(f"Finished read {sub_domain_name} mesh.")
 
         self.ndim = submesh.topology.dim
 
diff --git a/pvade/geometry/cylinder2d/DomainCreation.py b/pvade/geometry/cylinder2d/DomainCreation.py
index 525820e7..cb17ddef 100644
--- a/pvade/geometry/cylinder2d/DomainCreation.py
+++ b/pvade/geometry/cylinder2d/DomainCreation.py
@@ -21,7 +21,7 @@ def __init__(self, params):
         """
         super().__init__(params)
 
-    def build(self, params):
+    def build_FSI(self, params):
         """This function creates the computational domain for a flow around a 2D cylinder.
 
         Returns:
@@ -45,3 +45,5 @@ def build(self, params):
         self.gmsh_model.occ.cut([(2, rectangle)], [(2, obstacle)])
 
         self.gmsh_model.occ.synchronize()
+
+        self.numpy_pt_total_array = np.zeros((3, 6))
diff --git a/pvade/geometry/cylinder3d/DomainCreation.py b/pvade/geometry/cylinder3d/DomainCreation.py
index b54cb8d5..e139c42b 100644
--- a/pvade/geometry/cylinder3d/DomainCreation.py
+++ b/pvade/geometry/cylinder3d/DomainCreation.py
@@ -20,7 +20,7 @@ def __init__(self, params):
         """
         super().__init__(params)
 
-    def build(self, params):
+    def build_FSI(self, params):
         """This function creates the computational domain for a flow around a 3D cylinder.
 
         Returns:
@@ -52,6 +52,7 @@ def build(self, params):
         self.gmsh_model.occ.cut([(3, domain)], [(3, cylinder)])
 
         self.gmsh_model.occ.synchronize()
+        self.numpy_pt_total_array = np.zeros((3, 6))
 
     def set_length_scales(self, params, domain_markers):
         res_min = params.domain.l_char
diff --git a/pvade/structure/ElasticityAnalysis.py b/pvade/structure/ElasticityAnalysis.py
index 13ecba2d..4a84d988 100644
--- a/pvade/structure/ElasticityAnalysis.py
+++ b/pvade/structure/ElasticityAnalysis.py
@@ -40,9 +40,6 @@ def __init__(self, domain, structural_analysis, params):
         self.rank = domain.rank
         self.num_procs = domain.num_procs
 
-        # # domain.structure.msh = dolfinx.mesh.refine(domain.structure.msh,None)
-        # # domain.structure.msh = dolfinx.mesh.refine(domain.structure.msh)
-
         P1 = ufl.VectorElement("Lagrange", domain.structure.msh.ufl_cell(), 2)
         self.V = dolfinx.fem.FunctionSpace(domain.structure.msh, P1)
 
@@ -69,85 +66,6 @@ def __init__(self, domain, structural_analysis, params):
         # time step
         self.dt_st = dolfinx.fem.Constant(domain.structure.msh, (params.structure.dt))
 
-        # # Store the dimension of the problem for convenience
-        # self.ndim = domain.structure.msh.topology.dim
-        # self.facet_dim = self.ndim - 1
-
-        # # find hmin in mesh
-        # num_cells = domain.structure.msh.topology.index_map(self.ndim).size_local
-        # h = dolfinx.cpp.mesh.h(domain.structure.msh, self.ndim, range(num_cells))
-
-        # # This value of hmin is local to the mesh portion owned by the process
-        # hmin_local = np.amin(h)
-
-        # # collect the minimum hmin from all processes
-        # self.hmin = np.zeros(1)
-        # self.comm.Allreduce(hmin_local, self.hmin, op=MPI.MIN)
-        # self.hmin = self.hmin[0]
-
-        # if self.rank == 0:
-        #     print(f"hmin on structure = {self.hmin}")
-        #     print(f"Total num dofs on structure = {self.num_V_dofs}")
-
-        # # Mass density
-        # self.rho = dolfinx.fem.Constant(
-        #     domain.structure.msh, params.structure.rho
-        # )  # Constant(0.)
-
-        # # Rayleigh damping coefficients
-        # self.eta_m = dolfinx.fem.Constant(domain.structure.msh, 0.0)  # Constant(0.)
-        # self.eta_k = dolfinx.fem.Constant(domain.structure.msh, 0.0)  # Constant(0.)
-
-        # # Generalized-alpha method parameters
-        # self.alpha_m = dolfinx.fem.Constant(domain.structure.msh, 0.2)
-        # self.alpha_f = dolfinx.fem.Constant(domain.structure.msh, 0.4)
-        # self.gamma = 0.5 + self.alpha_f - self.alpha_m
-        # self.beta = (self.gamma + 0.5) ** 2 / 4.0
-
-        # # Define structural properties
-        # self.E = params.structure.elasticity_modulus  # 1.0e9
-        # self.ν = params.structure.poissons_ratio  # 0.3
-        # self.μ = self.E / (2.0 * (1.0 + self.ν))
-        # self.λ = self.E * self.ν / ((1.0 + self.ν) * (1.0 - 2.0 * self.ν))
-
-        # if self.rank == 0:
-        #     print(
-        #         f"mu = {self.μ} lambda = {self.λ} E = {self.E} nu = {self.ν} density = {self.rho.value}"
-        #     )
-
-        # # time step
-        # self.dt_st = dolfinx.fem.Constant(domain.structure.msh, (params.structure.dt))
-
-        # def _north_east_corner(x):
-        #     eps = 1.0e-6
-
-        #     # TODO: allow the probing of (x,y,z) points as something specified in the yaml file
-        #     if params.general.geometry_module == "flag2d":
-        #         # TEMP Hack for Turek and Hron Flag
-        #         x1 = 0.6
-        #         x2 = 0.2
-        #         corner = [x1, x2]
-        #     else:
-        #         tracker_angle_rad = np.radians(params.pv_array.tracker_angle)
-        #         x1 = 0.5 * params.pv_array.panel_chord * np.cos(tracker_angle_rad)
-        #         x2 = 0.5 * params.pv_array.panel_thickness * np.sin(tracker_angle_rad)
-        #         corner = [x1 - x2, 0.5 * params.pv_array.panel_span]
-
-        #     east_edge = np.logical_and(corner[0] - eps < x[0], x[0] < corner[0] + eps)
-        #     north_edge = np.logical_and(corner[1] - eps < x[1], x[1] < corner[1] + eps)
-
-        #     north_east_corner = np.logical_and(east_edge, north_edge)
-
-        #     return north_east_corner
-
-        # north_east_corner_facets = dolfinx.mesh.locate_entities_boundary(
-        #     domain.structure.msh, 0, _north_east_corner
-        # )
-
-        # self.north_east_corner_dofs = dolfinx.fem.locate_dofs_topological(
-        #     self.V, 0, north_east_corner_facets
-        # )
-
     def build_boundary_conditions(self, domain, params):
         """Build the boundary conditions
 
@@ -232,70 +150,68 @@ def build_forms(self, domain, params, structure):
         P3 = ufl.TensorElement("Lagrange", domain.structure.msh.ufl_cell(), 2)
         self.T = dolfinx.fem.FunctionSpace(domain.structure.msh, P3)
 
+        self.trial_tensor = ufl.TrialFunction(self.T)
+        self.test_tensor = ufl.TestFunction(self.T)
+        self.internal_stress = dolfinx.fem.Function(self.T, name="stress_structure")
+
         self.stress = dolfinx.fem.Function(self.T, name="stress_fluid")
         self.stress_old = dolfinx.fem.Function(self.T, name="stress_fluid_old")
         self.stress_predicted = dolfinx.fem.Function(
             self.T, name="stress_fluid_predicted"
         )
 
-        self.sigma_vm_h = dolfinx.fem.Function(self.W, name="Stress")
+        # self.sigma_vm_h = dolfinx.fem.Function(self.W, name="Stress")
 
         # discplacement
-        self.u = dolfinx.fem.Function(self.V, name="Deformation")
-        self.u_old = dolfinx.fem.Function(self.V, name="Deformation_old")
-        self.u_delta = dolfinx.fem.Function(self.V, name="Deformation_change")
+        self.u = dolfinx.fem.Function(self.V, name="deformation")
+        self.u_old = dolfinx.fem.Function(self.V, name="deformation_old")
+        self.u_delta = dolfinx.fem.Function(self.V, name="deformation_change")
 
         # velocity
-        self.v = dolfinx.fem.Function(self.V, name="Velocity")
-        self.v_old = dolfinx.fem.Function(self.V, name="Velocity_old")
+        self.v = dolfinx.fem.Function(self.V)
+        self.v_old = dolfinx.fem.Function(self.V, name="velocity")
 
         # acceleration
-        self.a = dolfinx.fem.Function(self.V, name="acceleration")
-        self.a_old = dolfinx.fem.Function(self.V, name="acceleration_old")
+        self.a = dolfinx.fem.Function(self.V)
+        self.a_old = dolfinx.fem.Function(self.V, name="acceleration")
 
         # dss = ufl.ds(subdomain_data=boundary_subdomains)
 
-        # # Stress tensor
         # def sigma(r):
-        #     return dolfinx.fem.form(2.0*self.μ*ufl.sym(ufl.grad(r)) + self.λ *ufl.tr(ufl.sym(ufl.grad(r)))*ufl.Identity(len(r)))
+        #     return dolfinx.fem.form(2.0*self.lame_mu*ufl.sym(ufl.grad(r)) + self.lame_lambda *ufl.tr(ufl.sym(ufl.grad(r)))*ufl.Identity(len(r)))
 
         # # Mass form
         # def m(u, u_):
         #     return dolfinx.fem.form(self.rho*ufl.inner(u, u_)*ufl.dx)
 
         # # Elastic stiffness form
-        # def k(u, u_):
+        # def k_nominal(u, u_):
         #     return dolfinx.fem.form(ufl.inner(sigma(u), ufl.sym(ufl.grad(u_)))*ufl.dx)
 
         # # Rayleigh damping form
         # def c(u, u_):
-        #     return dolfinx.fem.form(self.eta_m*m(u, u_) + self.eta_k*k(u, u_))
+        #     return dolfinx.fem.form(self.eta_m*m(u, u_) + self.eta_k*k_nominal(u, u_))
 
         # # Work of external forces
         # def Wext(u_):
         #     return ufl.dot(u_, self.f)*self.ds #dss(3)
 
-        def sigma(r):
-            return structure.λ * ufl.nabla_div(r) * ufl.Identity(
-                len(r)
-            ) + 2 * structure.μ * ufl.sym(ufl.grad(r))
+        # def sigma(r):
+        #     return structure.lame_lambda * ufl.nabla_div(r) * ufl.Identity(
+        #         len(r)
+        #     ) + 2 * structure.lame_mu * ufl.sym(ufl.grad(r))
 
         def m(u, u_):
-            return structure.rho * ufl.inner(u, u_) * ufl.dx
+            return structure.rho * ufl.inner(u, u_)
 
-        def k(u, u_):
-            return ufl.inner(sigma(u), ufl.grad(u_)) * ufl.dx
+        def c(u, u_):
+            return self.eta_m * m(u, u_) + self.eta_k * k_nominal(u, u_)
 
-        def k(u, u_):
-            # return ufl.inner(sigma(u),ufl.grad(u_))*ufl.dx
-            # updated lagrangian form
-            F = ufl.grad(u) + ufl.Identity(len(u))
-            E = 0.5 * (F.T * F - ufl.Identity(len(u)))
-            # S = self.λ *ufl.tr(E)*ufl.Identity(len(u))   + 2*self.μ * (E - ufl.tr(E)*ufl.Identity(len(u))  /3.0)
-            S = structure.λ * ufl.tr(E) * ufl.Identity(len(u)) + 2 * structure.μ * (E)
+        # def k_cauchy(u, u_):
+        #     return ufl.inner(sigma(u), ufl.grad(u_))
 
-            # return ufl.inner(F * S, ufl.grad(u_)) * ufl.dx
-            return ufl.inner(P_(u), ufl.grad(u_)) * ufl.dx
+        def k_nominal(u, u_):
+            return ufl.inner(P_(u), ufl.grad(u_))
 
         # The deformation gradient, F = I + dy/dX
         def F_(u):
@@ -323,7 +239,7 @@ def S_(u):
             # return lamda * ufl.tr(E) * I + 2.0 * mu * (E - ufl.tr(E) * I / 3.0)
             # TODO: Why does the above form give a better result and where does it come from?
 
-            S_svk = structure.λ * ufl.tr(E) * I + 2.0 * structure.μ * E
+            S_svk = structure.lame_lambda * ufl.tr(E) * I + 2.0 * structure.lame_mu * E
             return S_svk
 
         # The first Piola–Kirchhoff stress tensor, P = F*S
@@ -333,16 +249,13 @@ def P_(u):
             # return ufl.inv(F) * S
             return F * S
 
-        def c(u, u_):
-            return self.eta_m * m(u, u_) + self.eta_k * k(u, u_)
-
         # self.uh_exp = dolfinx.fem.Function(self.V,  name="Deformation")
 
-        def σ(v):
-            """Return an expression for the stress σ given a displacement field"""
-            return 2.0 * structure.μ * ufl.sym(ufl.grad(v)) + structure.λ * ufl.tr(
-                ufl.sym(ufl.grad(v))
-            ) * ufl.Identity(len(v))
+        # def σ(v):
+        #     """Return an expression for the stress σ given a displacement field"""
+        #     return 2.0 * structure.lame_mu * ufl.sym(ufl.grad(v)) + structure.lame_lambda * ufl.tr(
+        #         ufl.sym(ufl.grad(v))
+        #     ) * ufl.Identity(len(v))
 
         # source term ($f = \rho \omega^2 [x_0, \, x_1]$)
         # self.ω, self.ρ = 300.0, 10.0
@@ -390,9 +303,9 @@ def σ(v):
         F = ufl.grad(self.u) + ufl.Identity(len(self.u))
         J = ufl.det(F)
         self.res = (
-            m(self.avg(self.a_old, a_new, self.alpha_m), self.u_)
-            + c(self.avg(self.v_old, v_new, self.alpha_f), self.u_)
-            + k(self.avg(self.u_old, self.u, self.alpha_f), self.u_)
+            m(self.avg(self.a_old, a_new, self.alpha_m), self.u_) * ufl.dx
+            + c(self.avg(self.v_old, v_new, self.alpha_f), self.u_) * ufl.dx
+            + k_nominal(self.avg(self.u_old, self.u, self.alpha_f), self.u_) * ufl.dx
             - structure.rho * ufl.inner(self.f, self.u_) * ufl.dx
             - ufl.dot(ufl.dot(self.stress_predicted * J * ufl.inv(F.T), n), self.u_)
             * self.ds
@@ -401,6 +314,16 @@ def σ(v):
         # self.a = dolfinx.fem.form(ufl.lhs(res))
         # self.L = dolfinx.fem.form(ufl.rhs(res))
 
+        # Save a form to project the first Piola–Kirchhoff, P_, stress tensor in the structure
+        # u * v * dx = P_ * v * dx, where u and v are trial and test functions on tensor function space
+        F_k_nominal_proj = ufl.inner(self.trial_tensor, self.test_tensor) * ufl.dx
+        F_k_nominal_proj -= (
+            ufl.inner(P_(self.avg(self.u_old, self.u, self.alpha_f)), self.test_tensor)
+            * ufl.dx
+        )
+
+        self.k_nominal_proj = F_k_nominal_proj
+
         # self.a = dolfinx.fem.form(ufl.inner(σ(self.u), ufl.grad(self.v)) * ufl.dx)
         # self.L = dolfinx.fem.form(
         #     ufl.dot(self.f, self.v) * ufl.dx
@@ -518,7 +441,7 @@ def build_nullspace(self, V):
     def solve(self, params, dataIO, structure):
         # def σ(v):
         #     """Return an expression for the stress σ given a displacement field"""
-        #     return 2.0 * self.μ * ufl.sym(ufl.grad(v)) + self.λ * ufl.tr(
+        #     return 2.0 * self.lame_mu * ufl.sym(ufl.grad(v)) + self.lame_lambda * ufl.tr(
         #         ufl.sym(ufl.grad(v))
         #     ) * ufl.Identity(len(v))
 
diff --git a/pvade/structure/ModalAnalysis.py b/pvade/structure/ModalAnalysis.py
index 732943c3..62163505 100644
--- a/pvade/structure/ModalAnalysis.py
+++ b/pvade/structure/ModalAnalysis.py
@@ -93,13 +93,17 @@ def __init__(self, domain, structural_analysis, params):
 
         # Define structural properties
         self.E = params.structure.elasticity_modulus  # 1.0e9
-        self.ν = params.structure.poissons_ratio  # 0.3
-        self.μ = self.E / (2.0 * (1.0 + self.ν))
-        self.λ = self.E * self.ν / ((1.0 + self.ν) * (1.0 - 2.0 * self.ν))
+        self.poissons_ratio = params.structure.poissons_ratio  # 0.3
+        self.lame_mu = self.E / (2.0 * (1.0 + self.poissons_ratio))
+        self.lame_lambda = (
+            self.E
+            * self.poissons_ratio
+            / ((1.0 + self.poissons_ratio) * (1.0 - 2.0 * self.poissons_ratio))
+        )
 
         if self.rank == 0:
             print(
-                f"mu = {self.μ} lambda = {self.λ} E = {self.E} nu = {self.ν} density = {self.rho.value}"
+                f"mu = {self.lame_mu} lambda = {self.lame_lambda} E = {self.E} nu = {self.poissons_ratio} density = {self.rho.value}"
             )
 
         # time step
@@ -334,42 +338,44 @@ def build_forms(self, domain, params):
 
         # # Stress tensor
         # def sigma(r):
-        #     return dolfinx.fem.form(2.0*self.μ*ufl.sym(ufl.grad(r)) + self.λ *ufl.tr(ufl.sym(ufl.grad(r)))*ufl.Identity(len(r)))
+        #     return dolfinx.fem.form(2.0*self.lame_mu*ufl.sym(ufl.grad(r)) + self.lame_lambda *ufl.tr(ufl.sym(ufl.grad(r)))*ufl.Identity(len(r)))
 
         # # Mass form
         # def m(u, u_):
         #     return dolfinx.fem.form(self.rho*ufl.inner(u, u_)*ufl.dx)
 
         # # Elastic stiffness form
-        # def k(u, u_):
+        # def k_nominal(u, u_):
         #     return dolfinx.fem.form(ufl.inner(sigma(u), ufl.sym(ufl.grad(u_)))*ufl.dx)
 
         # # Rayleigh damping form
         # def c(u, u_):
-        #     return dolfinx.fem.form(self.eta_m*m(u, u_) + self.eta_k*k(u, u_))
+        #     return dolfinx.fem.form(self.eta_m*m(u, u_) + self.eta_k*k_nominal(u, u_))
 
         # # Work of external forces
         # def Wext(u_):
         #     return ufl.dot(u_, self.f)*self.ds #dss(3)
 
         def sigma(r):
-            return self.λ * ufl.nabla_div(r) * ufl.Identity(
+            return self.lame_lambda * ufl.nabla_div(r) * ufl.Identity(
                 len(r)
-            ) + 2 * self.μ * ufl.sym(ufl.grad(r))
+            ) + 2 * self.lame_mu * ufl.sym(ufl.grad(r))
 
         def m(u, u_):
             return self.rho * ufl.inner(u, u_) * ufl.dx
 
-        def k(u, u_):
+        def k_cauchy(u, u_):
             return ufl.inner(sigma(u), ufl.grad(u_)) * ufl.dx
 
-        def k(u, u_):
+        def k_nominal(u, u_):
             # return ufl.inner(sigma(u),ufl.grad(u_))*ufl.dx
             # updated lagrangian form
             F = ufl.grad(u) + ufl.Identity(len(u))
             E = 0.5 * (F.T * F - ufl.Identity(len(u)))
-            # S = self.λ *ufl.tr(E)*ufl.Identity(len(u))   + 2*self.μ * (E - ufl.tr(E)*ufl.Identity(len(u))  /3.0)
-            S = self.λ * ufl.tr(E) * ufl.Identity(len(u)) + 2 * self.μ * (E)
+            # S = self.lame_lambda *ufl.tr(E)*ufl.Identity(len(u))   + 2*self.lame_mu * (E - ufl.tr(E)*ufl.Identity(len(u))  /3.0)
+            S = self.lame_lambda * ufl.tr(E) * ufl.Identity(
+                len(u)
+            ) + 2 * self.lame_mu * (E)
 
             # return ufl.inner(F * S, ufl.grad(u_)) * ufl.dx
             return ufl.inner(P_(u), ufl.grad(u_)) * ufl.dx
@@ -400,7 +406,7 @@ def S_(u):
             # return lamda * ufl.tr(E) * I + 2.0 * mu * (E - ufl.tr(E) * I / 3.0)
             # TODO: Why does the above form give a better result and where does it come from?
 
-            S_svk = self.λ * ufl.tr(E) * I + 2.0 * self.μ * E
+            S_svk = self.lame_lambda * ufl.tr(E) * I + 2.0 * self.lame_mu * E
             return S_svk
 
         # The first Piola–Kirchhoff stress tensor, P = F*S
@@ -411,15 +417,15 @@ def P_(u):
             return F * S
 
         def c(u, u_):
-            return self.eta_m * m(u, u_) + self.eta_k * k(u, u_)
+            return self.eta_m * m(u, u_) + self.eta_k * k_nominal(u, u_)
 
         # self.uh_exp = dolfinx.fem.Function(self.V,  name="Deformation")
 
-        def σ(v):
-            """Return an expression for the stress σ given a displacement field"""
-            return 2.0 * self.μ * ufl.sym(ufl.grad(v)) + self.λ * ufl.tr(
-                ufl.sym(ufl.grad(v))
-            ) * ufl.Identity(len(v))
+        # def σ(v):
+        #     """Return an expression for the stress σ given a displacement field"""
+        #     return 2.0 * self.lame_mu * ufl.sym(ufl.grad(v)) + self.lame_lambda * ufl.tr(
+        #         ufl.sym(ufl.grad(v))
+        #     ) * ufl.Identity(len(v))
 
         # source term ($f = \rho \omega^2 [x_0, \, x_1]$)
         # self.ω, self.ρ = 300.0, 10.0
@@ -458,7 +464,7 @@ def σ(v):
         self.res = (
             m(self.avg(self.a_old, a_new, self.alpha_m), self.u_)
             + c(self.avg(self.v_old, v_new, self.alpha_f), self.u_)
-            + k(self.avg(self.u_old, self.u, self.alpha_f), self.u_)
+            + k_nominal(self.avg(self.u_old, self.u, self.alpha_f), self.u_)
             - self.rho * ufl.inner(self.f, self.u_) * ufl.dx
             - ufl.dot(ufl.dot(self.stress_predicted * J * ufl.inv(F.T), n), self.u_)
             * self.ds
@@ -584,7 +590,7 @@ def build_nullspace(self, V):
     def solve(self, params, dataIO):
         # def σ(v):
         #     """Return an expression for the stress σ given a displacement field"""
-        #     return 2.0 * self.μ * ufl.sym(ufl.grad(v)) + self.λ * ufl.tr(
+        #     return 2.0 * self.lame_mu * ufl.sym(ufl.grad(v)) + self.lame_lambda * ufl.tr(
         #         ufl.sym(ufl.grad(v))
         #     ) * ufl.Identity(len(v))
 
diff --git a/pvade/structure/StructureMain.py b/pvade/structure/StructureMain.py
index 68fd33f2..6e55265d 100644
--- a/pvade/structure/StructureMain.py
+++ b/pvade/structure/StructureMain.py
@@ -42,37 +42,9 @@ def __init__(self, domain, params):
         self.rank = domain.rank
         self.num_procs = domain.num_procs
 
-        # domain.structure.msh = dolfinx.mesh.refine(domain.structure.msh,None)
-        # domain.structure.msh = dolfinx.mesh.refine(domain.structure.msh)
-
-        # physics = 'ElasticityAnalysis'
-
-        # domain_creation_module = (
-        #     # f"pvade.geometry.{params.general.geometry_module}.DomainCreation"
-        #     f"pvade.structure.{physics}.Elasticity"
-        # )
-        # try:
-        #     # This is equivalent to "import pvade.geometry.{params.general.geometry_module}.DomainCreation as dcm"
-        #     dcm = import_module(domain_creation_module)
-        # except:
-        #     raise ValueError(f"Could not import {domain_creation_module}")
-
         # init physics
         self.elasticity = Elasticity(domain, self.structural_analysis, params)
 
-        # P1 = ufl.VectorElement("Lagrange", domain.structure.msh.ufl_cell(), 2)
-        # self.V = dolfinx.fem.FunctionSpace(domain.structure.msh, P1)
-
-        # self.W = dolfinx.fem.FunctionSpace(
-        #     domain.structure.msh, ("Discontinuous Lagrange", 0)
-        # )
-
-        # self.first_call_to_solver = True
-
-        # self.num_V_dofs = (
-        #     self.V.dofmap.index_map_bs * self.V.dofmap.index_map.size_global
-        # )
-
         # Store the dimension of the problem for convenience
         self.ndim = domain.structure.msh.topology.dim
         self.facet_dim = self.ndim - 1
@@ -81,13 +53,22 @@ def __init__(self, domain, params):
         num_cells = domain.structure.msh.topology.index_map(self.ndim).size_local
         h = dolfinx.cpp.mesh.h(domain.structure.msh, self.ndim, range(num_cells))
 
-        # This value of hmin is local to the mesh portion owned by the process
-        hmin_local = np.amin(h)
+        # # This value of hmin is local to the mesh portion owned by the process
+        # hmin_local = np.amin(h)
+
+        if len(h) > 0:
+            hmin_local = np.amin(h)
+        else:
+            hmin_local = np.inf
 
-        # collect the minimum hmin from all processes
+        print(hmin_local)
         self.hmin = np.zeros(1)
-        self.comm.Allreduce(hmin_local, self.hmin, op=MPI.MIN)
-        self.hmin = self.hmin[0]
+        self.hmin = self.comm.allreduce(hmin_local, op=MPI.MIN)
+
+        # # collect the minimum hmin from all processes
+        # self.hmin = np.zeros(1)
+        # self.comm.Allreduce(hmin_local, self.hmin, op=MPI.MIN)
+        # self.hmin = self.hmin[0]
 
         self.num_V_dofs = self.elasticity.num_V_dofs
         if self.rank == 0:
@@ -99,25 +80,19 @@ def __init__(self, domain, params):
             domain.structure.msh, params.structure.rho
         )  # Constant(0.)
 
-        # # Rayleigh damping coefficients
-        # self.eta_m = dolfinx.fem.Constant(domain.structure.msh, 0.0)  # Constant(0.)
-        # self.eta_k = dolfinx.fem.Constant(domain.structure.msh, 0.0)  # Constant(0.)
-
-        # # Generalized-alpha method parameters
-        # self.alpha_m = dolfinx.fem.Constant(domain.structure.msh, 0.2)
-        # self.alpha_f = dolfinx.fem.Constant(domain.structure.msh, 0.4)
-        # self.gamma = 0.5 + self.alpha_f - self.alpha_m
-        # self.beta = (self.gamma + 0.5) ** 2 / 4.0
-
         # Define structural properties
         self.E = params.structure.elasticity_modulus  # 1.0e9
-        self.ν = params.structure.poissons_ratio  # 0.3
-        self.μ = self.E / (2.0 * (1.0 + self.ν))
-        self.λ = self.E * self.ν / ((1.0 + self.ν) * (1.0 - 2.0 * self.ν))
+        self.poissons_ratio = params.structure.poissons_ratio  # 0.3
+        self.lame_mu = self.E / (2.0 * (1.0 + self.poissons_ratio))
+        self.lame_lambda = (
+            self.E
+            * self.poissons_ratio
+            / ((1.0 + self.poissons_ratio) * (1.0 - 2.0 * self.poissons_ratio))
+        )
 
         if self.rank == 0:
             print(
-                f"mu = {self.μ} lambda = {self.λ} E = {self.E} nu = {self.ν} density = {self.rho.value}"
+                f"mu = {self.lame_mu} lambda = {self.lame_lambda} E = {self.E} nu = {self.poissons_ratio} density = {self.rho.value}"
             )
 
         def _north_east_corner(x):
@@ -232,177 +207,6 @@ def build_forms(self, domain, params):
         """
         self.elasticity.build_forms(domain, params, self)
 
-        # # Define trial and test functions for deformation
-        # # self.du = ufl.TrialFunction(self.V)
-        # self.u_ = ufl.TestFunction(self.V)
-
-        # P3 = ufl.TensorElement("Lagrange", domain.structure.msh.ufl_cell(), 2)
-        # self.T = dolfinx.fem.FunctionSpace(domain.structure.msh, P3)
-
-        # self.stress = dolfinx.fem.Function(self.T, name="stress_fluid")
-        # self.stress_old = dolfinx.fem.Function(self.T, name="stress_fluid_old")
-        # self.stress_predicted = dolfinx.fem.Function(
-        #     self.T, name="stress_fluid_predicted"
-        # )
-
-        # self.sigma_vm_h = dolfinx.fem.Function(self.W, name="Stress")
-
-        # # discplacement
-        # self.u = dolfinx.fem.Function(self.V, name="Deformation")
-        # self.u_old = dolfinx.fem.Function(self.V, name="Deformation_old")
-        # self.u_delta = dolfinx.fem.Function(self.V, name="Deformation_change")
-
-        # # velocity
-        # self.v = dolfinx.fem.Function(self.V, name="Velocity")
-        # self.v_old = dolfinx.fem.Function(self.V, name="Velocity_old")
-
-        # # acceleration
-        # self.a = dolfinx.fem.Function(self.V, name="acceleration")
-        # self.a_old = dolfinx.fem.Function(self.V, name="acceleration_old")
-
-        # # dss = ufl.ds(subdomain_data=boundary_subdomains)
-
-        # # # Stress tensor
-        # # def sigma(r):
-        # #     return dolfinx.fem.form(2.0*self.μ*ufl.sym(ufl.grad(r)) + self.λ *ufl.tr(ufl.sym(ufl.grad(r)))*ufl.Identity(len(r)))
-
-        # # # Mass form
-        # # def m(u, u_):
-        # #     return dolfinx.fem.form(self.rho*ufl.inner(u, u_)*ufl.dx)
-
-        # # # Elastic stiffness form
-        # # def k(u, u_):
-        # #     return dolfinx.fem.form(ufl.inner(sigma(u), ufl.sym(ufl.grad(u_)))*ufl.dx)
-
-        # # # Rayleigh damping form
-        # # def c(u, u_):
-        # #     return dolfinx.fem.form(self.eta_m*m(u, u_) + self.eta_k*k(u, u_))
-
-        # # # Work of external forces
-        # # def Wext(u_):
-        # #     return ufl.dot(u_, self.f)*self.ds #dss(3)
-
-        # def sigma(r):
-        #     return self.λ * ufl.nabla_div(r) * ufl.Identity(
-        #         len(r)
-        #     ) + 2 * self.μ * ufl.sym(ufl.grad(r))
-
-        # def m(u, u_):
-        #     return self.rho * ufl.inner(u, u_) * ufl.dx
-
-        # def k(u, u_):
-        #     return ufl.inner(sigma(u), ufl.grad(u_)) * ufl.dx
-
-        # def k(u, u_):
-        #     # return ufl.inner(sigma(u),ufl.grad(u_))*ufl.dx
-        #     # updated lagrangian form
-        #     F = ufl.grad(u) + ufl.Identity(len(u))
-        #     E = 0.5 * (F.T * F - ufl.Identity(len(u)))
-        #     # S = self.λ *ufl.tr(E)*ufl.Identity(len(u))   + 2*self.μ * (E - ufl.tr(E)*ufl.Identity(len(u))  /3.0)
-        #     S = self.λ * ufl.tr(E) * ufl.Identity(len(u)) + 2 * self.μ * (E)
-
-        #     # return ufl.inner(F * S, ufl.grad(u_)) * ufl.dx
-        #     return ufl.inner(P_(u), ufl.grad(u_)) * ufl.dx
-
-        # # The deformation gradient, F = I + dy/dX
-        # def F_(u):
-        #     I = ufl.Identity(len(u))
-        #     return I + ufl.grad(u)
-
-        # # The Cauchy-Green deformation tensor, C = F.T * F
-        # def C_(u):
-        #     F = F_(u)
-        #     return F.T * F
-
-        # # Green–Lagrange strain tensor, E = 0.5*(C - I)
-        # def E_(u):
-        #     I = ufl.Identity(len(u))
-        #     C = C_(u)
-
-        #     return 0.5 * (C - I)
-        #     # return 0.5 * (ufl.grad(u) + ufl.grad(u).T)
-
-        # # The second Piola–Kirchhoff stress, S
-        # def S_(u):
-        #     E = E_(u)
-        #     I = ufl.Identity(len(u))
-
-        #     # return lamda * ufl.tr(E) * I + 2.0 * mu * (E - ufl.tr(E) * I / 3.0)
-        #     # TODO: Why does the above form give a better result and where does it come from?
-
-        #     S_svk = self.λ * ufl.tr(E) * I + 2.0 * self.μ * E
-        #     return S_svk
-
-        # # The first Piola–Kirchhoff stress tensor, P = F*S
-        # def P_(u):
-        #     F = F_(u)
-        #     S = S_(u)
-        #     # return ufl.inv(F) * S
-        #     return F * S
-
-        # def c(u, u_):
-        #     return self.eta_m * m(u, u_) + self.eta_k * k(u, u_)
-
-        # # self.uh_exp = dolfinx.fem.Function(self.V,  name="Deformation")
-
-        # def σ(v):
-        #     """Return an expression for the stress σ given a displacement field"""
-        #     return 2.0 * self.μ * ufl.sym(ufl.grad(v)) + self.λ * ufl.tr(
-        #         ufl.sym(ufl.grad(v))
-        #     ) * ufl.Identity(len(v))
-
-        # # source term ($f = \rho \omega^2 [x_0, \, x_1]$)
-        # # self.ω, self.ρ = 300.0, 10.0
-        # # x = ufl.SpatialCoordinate(domain.structure.msh)
-        # # self.f = ufl.as_vector((0*self.ρ * self.ω**2 * x[0], self.ρ * self.ω**2 * x[1], 0.0))
-        # # self.f_structure = dolfinx.fem.Constant(
-        # #     domain.structure.msh,
-        # #     (PETSc.ScalarType(0), PETSc.ScalarType(0), PETSc.ScalarType(0)),
-        # # )
-        # # self.f = ufl.as_vector((0*self.ρ * self.ω**2 * x[0], self.ρ * self.ω**2 * x[1], 0.0))
-        # # self.T = dolfinx.fem.Constant(domain.structure.msh, PETSc.ScalarType((0, 1.e-3, 0)))
-        # # self.f = dolfinx.fem.Constant(domain.structure.msh, PETSc.ScalarType((0,100,100)))
-        # self.f = dolfinx.fem.Constant(
-        #     domain.structure.msh,
-        #     PETSc.ScalarType(
-        #         (
-        #             params.structure.body_force_x,
-        #             params.structure.body_force_y,
-        #             params.structure.body_force_z,
-        #         )
-        #     ),
-        # )
-        # self.ds = ufl.Measure("ds", domain=domain.structure.msh)
-        # n = ufl.FacetNormal(domain.structure.msh)
-
-        # # Residual
-        # a_new = self.update_a(
-        #     self.u, self.u_old, self.v_old, self.a_old, self.dt_st, self.beta, ufl=True
-        # )
-        # v_new = self.update_v(
-        #     a_new, self.u_old, self.v_old, self.a_old, self.dt_st, self.gamma, ufl=True
-        # )
-
-        # F = ufl.grad(self.u) + ufl.Identity(len(self.u))
-        # J = ufl.det(F)
-        # self.res = (
-        #     m(self.avg(self.a_old, a_new, self.alpha_m), self.u_)
-        #     + c(self.avg(self.v_old, v_new, self.alpha_f), self.u_)
-        #     + k(self.avg(self.u_old, self.u, self.alpha_f), self.u_)
-        #     - self.rho * ufl.inner(self.f, self.u_) * ufl.dx
-        #     - ufl.dot(ufl.dot(self.stress_predicted * J * ufl.inv(F.T), n), self.u_)
-        #     * self.ds
-        # )  # - Wext(self.u)
-
-        # # self.a = dolfinx.fem.form(ufl.lhs(res))
-        # # self.L = dolfinx.fem.form(ufl.rhs(res))
-
-        # # self.a = dolfinx.fem.form(ufl.inner(σ(self.u), ufl.grad(self.v)) * ufl.dx)
-        # # self.L = dolfinx.fem.form(
-        # #     ufl.dot(self.f, self.v) * ufl.dx
-        # #     + ufl.dot(ufl.dot(self.stress, n), self.v) * self.ds
-        # # )
-
     def _assemble_system(self, params):
         """Pre-assemble all LHS matrices and RHS vectors
 
@@ -514,88 +318,3 @@ def build_nullspace(self, V):
     def solve(self, params, dataIO):
 
         self.elasticity.solve(params, dataIO, self)
-        # # def σ(v):
-        # #     """Return an expression for the stress σ given a displacement field"""
-        # #     return 2.0 * self.μ * ufl.sym(ufl.grad(v)) + self.λ * ufl.tr(
-        # #         ufl.sym(ufl.grad(v))
-        # #     ) * ufl.Identity(len(v))
-
-        # if self.first_call_to_solver:
-        #     if self.rank == 0:
-        #         print("Starting Strutural Solution")
-
-        #     self._assemble_system(params)
-
-        # num_its, converged = self.solver.solve(self.u)  # solve the current time step
-        # assert converged
-        # self.u.x.scatter_forward()
-
-        # # Calculate the change in the displacement (new - old) this is what moves the mesh
-        # self.u_delta.vector.array[:] = (
-        #     self.u.vector.array[:] - self.u_old.vector.array[:]
-        # )
-        # self.u_delta.x.scatter_forward()
-
-        # # Update old fields with new quantities
-        # self.update_fields(
-        #     self.u,
-        #     self.u_old,
-        #     self.v_old,
-        #     self.a_old,
-        #     self.dt_st,
-        #     self.beta,
-        #     self.gamma,
-        # )
-
-        # # sigma_dev = σ(self.u) - (1 / 3) * ufl.tr(σ(self.u)) * ufl.Identity(len(self.u))
-        # # sigma_vm = ufl.sqrt((3 / 2) * ufl.inner(sigma_dev, sigma_dev))
-
-        # # sigma_vm_expr = dolfinx.fem.Expression(
-        # #     sigma_vm, self.W.element.interpolation_points()
-        # # )
-        # # self.sigma_vm_h.interpolate(sigma_vm_expr)
-
-        # # self.unorm = self.u.x.norm()
-
-        # try:
-        #     idx = self.north_east_corner_dofs[0]
-        #     nw_corner_accel = self.u.vector.array[3 * idx : 3 * idx + 3].astype(
-        #         np.float64
-        #     )
-        #     print(nw_corner_accel)
-        # except:
-        #     nw_corner_accel = np.zeros(3, dtype=np.float64)
-
-        # nw_corner_accel_global = np.zeros((self.num_procs, 3), dtype=np.float64)
-
-        # self.comm.Gather(nw_corner_accel, nw_corner_accel_global, root=0)
-
-        # # print(f"Acceleration at North West corner = {nw_corner_accel}")
-
-        # if self.rank == 0:
-        #     norm2 = np.sum(nw_corner_accel_global**2, axis=1)
-        #     max_norm2_idx = np.argmax(norm2)
-        #     np_accel = nw_corner_accel_global[max_norm2_idx, :]
-
-        #     accel_pos_filename = os.path.join(
-        #         params.general.output_dir_sol, "accel_pos.csv"
-        #     )
-
-        #     if self.first_call_to_solver:
-
-        #         with open(accel_pos_filename, "w") as fp:
-        #             fp.write("#x-pos,y-pos,z-pos\n")
-        #             if self.ndim == 3:
-        #                 fp.write(f"{np_accel[0]},{np_accel[1]},{np_accel[2]}\n")
-        #             elif self.ndim == 2:
-        #                 fp.write(f"{np_accel[0]},{np_accel[1]}\n")
-
-        #     else:
-        #         with open(accel_pos_filename, "a") as fp:
-        #             if self.ndim == 3:
-        #                 fp.write(f"{np_accel[0]},{np_accel[1]},{np_accel[2]}\n")
-        #             elif self.ndim == 2:
-        #                 fp.write(f"{np_accel[0]},{np_accel[1]}\n")
-
-        # if self.first_call_to_solver:
-        #     self.first_call_to_solver = False
diff --git a/pvade/structure/boundary_conditions.py b/pvade/structure/boundary_conditions.py
index 77bbe048..0aa0ea0e 100644
--- a/pvade/structure/boundary_conditions.py
+++ b/pvade/structure/boundary_conditions.py
@@ -120,42 +120,29 @@ def __call__(self, x):
         inflow_dy = H - x[1]
         inflow_dz = H - x[2]
 
-        u_hub = self.params.fluid.u_ref
+        if self.params.fluid.velocity_profile_type == "specified_from_file":
+            u_hub = self.u_ref
+        else:
+            u_hub = self.params.fluid.u_ref
+
         z_hub = self.params.pv_array.elevation
 
         if self.params.general.example == "cylinder3d":
-            inflow_values[0] = (
-                16.0
-                * self.params.fluid.u_ref
-                * x[1]
-                * x[2]
-                * inflow_dy
-                * inflow_dz
-                / H**4
-            )
+            inflow_values[0] = 16.0 * u_hub * x[1] * x[2] * inflow_dy * inflow_dz / H**4
         elif self.params.general.example == "cylinder2d":
             inflow_values[0] = (
-                4
-                * (self.params.fluid.u_ref)
-                * np.sin(np.pi / 8)
-                * x[1]
-                * (0.41 - x[1])
-                / (0.41**2)
+                4 * (u_hub) * np.sin(np.pi / 8) * x[1] * (0.41 - x[1]) / (0.41**2)
             )
         elif (
             self.params.general.example == "panels3d"
             or self.params.general.example == "heliostats3d"
         ):
             inflow_values[0] = (
-                (self.params.fluid.u_ref)
-                * np.log(((x[2]) - d0) / z0)
-                / (np.log((z_hub - d0) / z0))
+                (u_hub) * np.log(((x[2]) - d0) / z0) / (np.log((z_hub - d0) / z0))
             )
         elif self.params.general.example == "panels2d":
             inflow_values[0] = (
-                (self.params.fluid.u_ref)
-                * np.log(((x[1]) - d0) / z0)
-                / (np.log((z_hub - d0) / z0))
+                (u_hub) * np.log(((x[1]) - d0) / z0) / (np.log((z_hub - d0) / z0))
             )
 
         return inflow_values
diff --git a/pvade/tests/input/yaml/flag2d.yaml b/pvade/tests/input/yaml/flag2d.yaml
index 5fa34263..02124225 100644
--- a/pvade/tests/input/yaml/flag2d.yaml
+++ b/pvade/tests/input/yaml/flag2d.yaml
@@ -35,7 +35,7 @@ fluid:
   velocity_profile_type: parabolic
   inflow_coeff: 6.0
   u_ref: 1.0 # 0.2 1.0 2.0
-  time_varying_inflow_window: 2.0
+  ramp_window: 2.0
   rho: 1000.0 # 0.2 1.0 2.0
   nu: 0.001 # Establish re = 20 with diam = 0.1 and u = u_ref
   dpdx: 0.0
diff --git a/pvade/tests/input/yaml/sim_params.yaml b/pvade/tests/input/yaml/sim_params.yaml
index fd216a06..7b6e4a6b 100644
--- a/pvade/tests/input/yaml/sim_params.yaml
+++ b/pvade/tests/input/yaml/sim_params.yaml
@@ -15,6 +15,7 @@ domain:
   l_char: 20
 pv_array:
   stream_rows: 7
+  span_rows: 1
   elevation: 1.5
   stream_spacing: 7.0
   panel_chord: 2.0
diff --git a/pvade/tests/test_input_files.py b/pvade/tests/test_input_files.py
index 5354530e..01c13c86 100644
--- a/pvade/tests/test_input_files.py
+++ b/pvade/tests/test_input_files.py
@@ -19,7 +19,7 @@ def launch_sim(test_file):
     tf = dt * 10  # ten timesteps
 
     command = (
-        f"mpirun -n 2 python "
+        f"mpirun -n 8 python "
         + rootdir
         + "/pvade_main.py --input_file "
         + test_file["path_to_file"]
diff --git a/pvade/tests/test_solve.py b/pvade/tests/test_solve.py
index 41a8eb1f..8734207d 100644
--- a/pvade/tests/test_solve.py
+++ b/pvade/tests/test_solve.py
@@ -22,7 +22,7 @@
 
 solve_iter = 10
 
-rtol = 1.0e-4
+rtol = 1.0e-1
 
 
 @pytest.mark.unit
diff --git a/pvade_main.py b/pvade_main.py
index 4fd60c99..8bc322aa 100644
--- a/pvade_main.py
+++ b/pvade_main.py
@@ -1,5 +1,5 @@
 from pvade.fluid.FlowManager import Flow
-from pvade.IO.DataStream import DataStream
+from pvade.IO.DataStream import DataStream, start_print_and_log
 from pvade.fsi.FSI import FSI
 from pvade.IO.Parameters import SimParams
 from pvade.IO.Utilities import get_input_file, write_metrics
@@ -14,6 +14,7 @@
 
 from pvade.structure.StructureMain import Structure
 import os
+from mpi4py import MPI
 
 
 def main(input_file=None):
@@ -25,70 +26,55 @@ def main(input_file=None):
     # Load the parameters object specified by the input file
     params = SimParams(input_file)
 
+    # Save the parameters object to a logfile
+    logfile_name = os.path.join(params.general.output_dir, "logfile.log")
+    start_print_and_log(params.rank, logfile_name)
+
     fluid_analysis = params.general.fluid_analysis
     structural_analysis = params.general.structural_analysis
     thermal_analysis = params.general.thermal_analysis
 
     # Initialize the domain and construct the initial mesh
     domain = FSIDomain(params)
-
     if params.general.input_mesh_dir is not None:
         domain.read_mesh_files(params.general.input_mesh_dir, params)
     else:
         domain.build(params)
-        # domain.write_mesh_files(params)
 
+    # If we only want to create the mesh, we can stop here
     if params.general.mesh_only:
         list_timings(params.comm, [TimingType.wall])
         structure, flow = [], []
         return params, structure, flow
 
-    # Check to ensure mesh node matching for periodic simulations
-    # if domain.periodic_simulation:
-    # domain.check_mesh_periodicity(params)
-    # sys.exit()
-
-    # if params.general.debug_flag:
-    #     print('before Flow init')
-
-    flow = Flow(domain, params)
-    structure = Structure(domain, params)
-
     if fluid_analysis:
         flow = Flow(domain, params)
         # # # Specify the boundary conditions
         flow.build_boundary_conditions(domain, params)
         # # # Build the fluid forms
         flow.build_forms(domain, params)
+    else:
+        flow = None
 
     if structural_analysis:
+        structure = Structure(domain, params)
         structure.build_boundary_conditions(domain, params)
         # # # Build the fluid forms
         structure.build_forms(domain, params)
+    else:
+        structure = None
 
     if structural_analysis and fluid_analysis:
-        # pass
         domain.move_mesh(structure, params)
 
     dataIO = DataStream(domain, flow, structure, params)
     FSI_inter = FSI(domain, flow, structure, params)
-    # if domain.rank == 0:
-    #     progress = tqdm.autonotebook.tqdm(
-    #         desc="Solving PDE", total=params.solver.t_steps
-    #     )
 
     solve_structure_interval_n = int(params.structure.dt / params.solver.dt)
 
     for k in range(params.solver.t_steps):
         current_time = (k + 1) * params.solver.dt
 
-        # if domain.rank == 0:
-        #     progress.update(1)
-        #     print()
-        # Solve the fluid problem at each timestep
-
-        # print("time step is : ", current_time)
-        # print("reaminder from modulo ",current_time % params.structure.dt )
         if (
             structural_analysis
             and (k + 1) % solve_structure_interval_n == 0
@@ -136,12 +122,13 @@ def main(input_file=None):
                         print(f"| f_x (drag) = {fx:.4f}")
                         print(f"| f_y (lift) = {fy:.4f}")
                     else:
-                        # still print info, but just for first row
-                        fx = flow.integrated_force_x[0]
-                        fy = flow.integrated_force_y[0]
+                        if structure is not None:
+                            # still print info, but just for first row
+                            fx = flow.integrated_force_x[0]
+                            fy = flow.integrated_force_y[0]
 
-                        print(f"| f_x (drag) of 1st row = {fx:.4f}")
-                        print(f"| f_y (lift) of 1st row = {fy:.4f}")
+                            print(f"| f_x (drag) of 1st row = {fx:.4f}")
+                            print(f"| f_y (lift) of 1st row = {fy:.4f}")
                     if thermal_analysis:
                         print(f"| T = {flow.theta_max:.4f}")
 
@@ -153,15 +140,34 @@ def main(input_file=None):
                 and current_time > params.fluid.warm_up_time
             ):
 
-                local_def_max = np.amax(
-                    np.sum(
-                        structure.elasticity.u.vector.array.reshape(-1, domain.ndim)
-                        ** 2,
-                        axis=1,
-                    )
+                vec = structure.elasticity.u.vector
+                u_local = vec.array  # This gives a NumPy array on local rank
+
+                if u_local.size > 0:
+                    u_reshaped = u_local.reshape(-1, domain.ndim)
+                    local_def_max = np.amax(np.sum(u_reshaped**2, axis=1))
+                else:
+                    local_def_max = -np.inf  # So it doesn't interfere in max
+                print(
+                    f"Rank {domain.comm.rank}: u_vec.size = {u_local.size}, local_def_max = {local_def_max}"
                 )
-                global_def_max_list = np.zeros(params.num_procs, dtype=np.float64)
-                params.comm.Gather(local_def_max, global_def_max_list, root=0)
+
+                # Wrap scalar in NumPy array (required for Gather)
+                sendbuf = np.array([local_def_max], dtype=np.float64)
+
+                # Preallocate only on root
+                if params.comm.rank == 0:
+                    global_def_max_list = np.empty(params.num_procs, dtype=np.float64)
+                else:
+                    global_def_max_list = None
+
+                # Perform the gather
+                params.comm.Gather(sendbuf, global_def_max_list, root=0)
+
+                # Handle on root
+                if params.comm.rank == 0:
+                    print("Per-rank def max values:", global_def_max_list)
+                    print("Global def max:", np.max(global_def_max_list))
 
                 if domain.rank == 0:
                     # print("Structural time is : ", current_time)
@@ -195,4 +201,4 @@ def main(input_file=None):
             sys.stdout = sys.__stdout__
 
         if not params.general.mesh_only:
-            write_metrics(flow, structure.elasticity, prof_filename=prof_txt_filename)
+            write_metrics(flow, prof_filename=prof_txt_filename)
diff --git a/test_all_inputs.py b/test_all_inputs.py
new file mode 100644
index 00000000..5c85e2f1
--- /dev/null
+++ b/test_all_inputs.py
@@ -0,0 +1,56 @@
+import subprocess
+from pathlib import Path
+import pytest
+
+
+@pytest.mark.parametrize("mesh_only", [True, False])
+@pytest.mark.parametrize("nprocs", [1])
+def test_pvade_run(input_file, mesh_only, nprocs):
+    cmd = [
+        "mpirun",
+        "-n",
+        str(nprocs),
+        "python",
+        "-u",
+        "pvade_main.py",
+        "--input",
+        str(input_file.resolve()),
+        "--solver.dt",
+        "0.001",
+        "--solver.t_final",
+        "0.005",
+        "--general.mesh_only",
+        str(mesh_only).lower(),
+    ]
+
+    # Add special argument for duramat_case_study.yaml
+    if input_file.name in [
+        "duramat_case_study.yaml",
+        "turbinflow_duramat_case_study.yaml",
+    ]:
+        cmd += ["--domain.l_char", "4"]
+
+    print(
+        f"\n=== Running: {input_file.name} | mesh_only={mesh_only} | nprocs={nprocs} ==="
+    )
+    print("Command:", " ".join(cmd))
+
+    proc = subprocess.Popen(
+        cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True
+    )
+
+    print("OUTPUT LOG")
+    for line in proc.stdout:
+        print(line, end="")
+
+    if proc.stderr is not None:
+        print("ERROR LOG")
+        for line in proc.stderr:
+            print(line, end="")
+
+    proc.wait()
+
+    assert proc.returncode == 0, (
+        f"\nFAILED: {input_file.name} | mesh_only={mesh_only} | nprocs={nprocs}\n"
+        f"Exit code: {proc.returncode}"
+    )