Repository: slaclab/PyEmittance (language: python)

Issue:
Merging



Discussion / hints:

Fix patch:
diff --git a/.gitignore b/.gitignore
index 3b811ee..5ffe717 100644
--- a/.gitignore
+++ b/.gitignore
@@ -132,3 +132,6 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# Mac
+*.DS_Store
diff --git a/README.md b/README.md
index 8295863..9ff2fc0 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,15 @@
 # PyEmittance
 
-PyEmittance is a tool for the adaptive measurement of the emittance of an electron beam at OTR/YAG beam profile monitors using a scan with varying quadrupole strength. The Twiss parameters and the 'Bmag' match parameter can also be obtained. It can be used in different beamlines/machines by defining machine-specific configuration files.
+PyEmittance is a tool for the adaptive measurement of beam emittance (*e.g.* of an electron beam at OTR/YAG beam profile monitors) using a single quadrupole scan developed at SLAC National Accelerator Laboratory. The Twiss parameters and the 'Bmag' match parameter can also be obtained. It can be used in different beamlines/machines by defining machine-specific configuration files. 
+
+This tool was designed for robustness during online machine learning optimizations where each measurement needs to be reliable. It is still a work in progress, with version 1.0 to be released soon.
+
+
+Clone the repository and run the command below to install: 
+
+    pip install -e .
+
+Or install by running:
+    
+    pip install pyemittance
+    
diff --git a/examples/config_setup_example.ipynb b/examples/config_setup_example.ipynb
new file mode 100644
index 0000000..326be58
--- /dev/null
+++ b/examples/config_setup_example.ipynb
@@ -0,0 +1,115 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "66113a06-67af-4275-bb9f-cd84dc1784aa",
+   "metadata": {},
+   "source": [
+    "# Config files setup for EPICS systems\n",
+    "This notebook shows what config files you need and how to set them up. \n",
+    "\n",
+    "Note that this setup will be improved in the future to be only one json files with all machine information, removing the need for different directories"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6697856a-5866-4051-85dc-aa10a6056bdd",
+   "metadata": {},
+   "source": [
+    "<span style=\"color:red\">NOTE! make sure your files are the only **json** files in the directory *pyemittance/configs/* (delete or remove others)</span>.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe80a4b7-3852-4020-80c6-c48e2a884cb9",
+   "metadata": {},
+   "source": [
+    "Files needed:\n",
+    "1. beamline_info.json : required for measurements\n",
+    "2. img_proc.json :  required only if doing OTR image analysis (sigma units in meters, bg_im needs to be the path to the .npy file of the background image array)\n",
+    "3. meas_pv_info.json : required PVs for measurement devices (OTR, wire, quad)\n",
+    "4. opt_pv_info.json : required \"opt_vars\" if optimizing the emittance (setting injector configurations for solenoids, etc)\n",
+    "5. save_scalar_pvs.json : required if saving raw data from PVs, json just constains the PVs you want to save\n",
+    "6. savepaths.json : required for defining directories for saving"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c70ab0af-d7db-4e59-926d-0e41469156c1",
+   "metadata": {},
+   "source": [
+    "The most important file for the emittance computation is"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "88e77391-1cb1-4d85-a341-24e0e99bc878",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'name': 'LCLS',\n",
+       " 'm_0': 0.000511,\n",
+       " 'd': 2.26,\n",
+       " 'l': 0.108,\n",
+       " 'energy': 0.135,\n",
+       " 'Twiss0': [1e-06,\n",
+       "  1e-06,\n",
+       "  1.113081026,\n",
+       "  1.113021659,\n",
+       "  -0.0689403587,\n",
+       "  -0.07029489754],\n",
+       " 'rMat': [1, 2.26, 0, 1]}"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import json\n",
+    "json.load(open(\"../pyemittance/configs/beamline_info.json\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f7151769-b670-49c0-a8c8-817b19e9adc3",
+   "metadata": {},
+   "source": [
+    "The important params are:\n",
+    "- **beam_info['m_0']** : mass of the particle\n",
+    "- **beam_info['d']** : distance from scanning quad to OTR/wire [m]\n",
+    "- **beam_info['l']** : scanning quad effective length [m]\n",
+    "- **beam_info['energy']** : beam energy [GeV]\n",
+    "- **beam_info['Twiss0']** : design Twiss at measurement location (e_x, e_y, beta_x, beta_y, alpha_x, alpha_y)\n",
+    "- **beam_info['rMat']** : transport matrix from scanning to quad to OTR/screen, critical when there is more than a drift\n",
+    "(quads, etc) in between, and this r-matrix takes into account those contributions (need to get from external model).\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/lcls_optimizer.py b/examples/lcls_optimizer.py
new file mode 100644
index 0000000..c06313f
--- /dev/null
+++ b/examples/lcls_optimizer.py
@@ -0,0 +1,273 @@
+import numpy as np
+import datetime
+
+from bayes_opt import BayesianOptimization, UtilityFunction
+from scipy import optimize
+
+from pyemittance.emit_eval_example import eval_emit_machine
+
+class Opt:
+    def __init__(self, init_scan=[-6, -4, -2, 0]):
+        self.varscan = init_scan
+        self.num_points_adapt = 7
+        self.pbounds = ((0.46, 0.485), (-0.01, 0.01), (-0.01, 0.01))
+        self.plot = False
+        self.save_runs = False
+        self.online = False
+        self.uncertainty_lim = 0.25
+        self.timestamp = None
+        self.total_num_points = 0
+        self.seed = 12
+
+    def evaluate(self, varx, vary, varz):
+        # fixed initial varscan
+        quad_init = self.varscan
+        config = [varx, vary, varz]
+
+        out_dict, self.total_num_points = eval_emit_machine(config,
+                                                       quad_init=list(quad_init),
+                                                       online=self.online,
+                                                       name='LCLS',
+                                                       meas_type='OTRS',
+                                                       adapt_ranges=True,
+                                                       num_points=self.num_points_adapt,
+                                                       check_sym=True,
+                                                       infl_check=True,
+                                                       add_pnts=True,
+                                                       show_plots=self.plot,
+                                                       use_prev_meas=True,
+                                                       quad_tol=0.02,
+                                                       save_runs=self.save_runs,
+                                                       calc_bmag=True)
+
+        return out_dict
+
+    def evaluate_bo(self, varx, vary, varz):
+        out_dict = self.evaluate(varx, vary, varz)
+
+        emit = out_dict['nemit']
+        emit_err = out_dict['nemit_err']
+
+        if np.isnan(emit):
+            print("NaN emit")
+            return np.nan, np.nan
+
+        if emit_err / emit < self.uncertainty_lim:
+            # save total number of points added
+            timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+            f = open(f"bo_points_meas_iter.txt", "a+")
+            f.write(f'{varx},{vary},{varz},{emit},{emit_err},{self.total_num_points},{timestamp}\n')
+            f.close()
+
+        return -emit, -emit_err
+
+    def run_bo_opt_w_reject(self, rnd_state=11, init_pnts=3, n_iter=120):
+        np.random.seed(self.seed)
+
+        # Set domain
+        bounds = {'varx': self.pbounds[0], 'vary': self.pbounds[1], 'varz': self.pbounds[2]}
+
+        # Run BO
+        optimizer = BayesianOptimization(
+            f=None,
+            pbounds=bounds,
+            random_state=rnd_state,
+            verbose=2
+        )
+
+        # utility = UtilityFunction(kind="ucb", kappa=0.1, xi=0.0)
+        utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
+
+        target_list = []
+
+        # init random points
+        x = []
+        emit_list = []
+        emit_err_list = []
+
+        emit_res = (np.nan, np.nan)
+        while len(emit_list) < init_pnts:
+            x_i = [np.random.uniform(self.pbounds[0][0], self.pbounds[0][1]),
+                   np.random.uniform(self.pbounds[1][0], self.pbounds[1][1]),
+                   np.random.uniform(self.pbounds[2][0], self.pbounds[2][1])]
+            emit_res = self.evaluate(x_i[0], x_i[1], x_i[2])
+
+            if not np.isnan(emit_res[0]) and not np.isnan(emit_res[1]):# and abs(emit_res[0]) > 58e-8:
+                # take large init emittances
+                x.append(x_i)
+                emit_list.append(emit_res[0])
+                emit_err_list.append(emit_res[1])
+
+        print("Init configs: ", x)
+        print("Init emit: ", emit_list)
+        # get init points
+        for i in range(len(x)):
+            # target, error = np.nan, np.nan
+            # hile np.isnan(target) or np.isnan(error) or error/target > self.uncertainty_lim:
+            next_point = {'varx': x[i][0],
+                          'vary': x[i][1],
+                          'varz': x[i][2]
+                          }
+            #                 # evaluate next point
+            target = emit_list[i]
+
+            optimizer.register(params=next_point, target=target)
+            if target_list and target > np.max(target_list):
+                color = '\033[95m', '\033[0m'
+            else:
+                color = '\u001b[30m', '\033[0m'
+
+            print(
+                f"{color[0]}iter {i} | target {-1 * target/1e-6:.3f} | config {next_point['varx']:.6f} "
+                f"{next_point['vary']:.6f} {next_point['varz']:.6f}{color[1]}")
+            target_list.append(target)
+
+        # BO iters
+        for i in range(n_iter):
+            target, error = np.nan, np.nan
+            while np.isnan(target) or np.isnan(error) or error / target > self.uncertainty_lim:
+                next_point = optimizer.suggest(utility)
+                target, error = self.evaluate(**next_point)
+
+            optimizer.register(params=next_point, target=target)
+            if target_list and target > np.max(target_list):
+                color = '\033[95m', '\033[0m'
+            else:
+                color = '\u001b[30m', '\033[0m'
+
+            print(
+                f"{color[0]}iter {i} | target {-1 * target/1e-6:.3f} | config {next_point['varx']:.6f}"
+                f" {next_point['vary']:.6f} {next_point['varz']:.6f}{color[1]}")
+            emit_list.append(target)
+            emit_err_list.append(error)
+            target_list.append(target)
+
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+
+        np.save(f'bo_opt_res_emit_list_{rnd_state}_{init_pnts}_{n_iter}_{timestamp}.npy', emit_list,
+                allow_pickle=True)
+        np.save(f'bo_opt_res_emit_err_list_{rnd_state}_{init_pnts}_{n_iter}_{timestamp}.npy', emit_err_list,
+                allow_pickle=True)
+        np.save(f'bo_opt_res_{rnd_state}_{init_pnts}_{n_iter}_{timestamp}.npy', optimizer.res,
+                allow_pickle=True)
+
+        return optimizer
+
+    def eval_simplex(self, x):
+        out_dict = self.evaluate(x[0], x[1], x[2])
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+
+        emit = out_dict['nemit']
+        err = out_dict['nemit_err']
+        
+        if np.isnan(emit) or (err / emit > self.uncertainty_lim):
+            print("NaN or high uncertainty emittance, returning 100.")
+            f = open(f"simplex_run.txt", "a+")
+            f.write(f'{x[0]},{x[1]},{x[2]},{np.nan},{np.nan},{self.total_num_points},{timestamp}\n')
+            f.close()
+            return 100
+
+        f = open(f"simplex_run.txt", "a+")
+        f.write(f'{x[0]},{x[1]},{x[2]},{emit},{err},{self.total_num_points},{timestamp}\n')
+        f.close()
+
+        return emit
+
+    def run_simplex_opt(self, max_iter):
+
+        np.random.seed(self.seed)
+
+        initial_guess = np.array(
+            [np.random.uniform(self.pbounds[0][0], self.pbounds[0][1]),
+             np.random.uniform(self.pbounds[1][0], self.pbounds[1][1]),
+             np.random.uniform(self.pbounds[2][0], self.pbounds[2][1])
+             ])
+
+        # initial_guess1 = self.pbounds[0][0]+ np.random.rand(1) * (self.pbounds[0][1] - self.pbounds[0][0])
+        # initial_guess2 = self.pbounds[1][0]+ np.random.rand(1) * (self.pbounds[1][1] - self.pbounds[1][0])
+        # initial_guess3 = self.pbounds[2][0]+ np.random.rand(1) * (self.pbounds[2][1] - self.pbounds[2][0])
+
+        # initial_guess = np.array([initial_guess1, initial_guess2, initial_guess3])
+
+        min = optimize.minimize(self.eval_simplex, initial_guess,
+                                method='Nelder-Mead', options={'maxiter': max_iter,
+                                                               'return_all': True,
+                                                               'adaptive': True,
+                                                               'fatol': 0.1 * 0.75,
+                                                               'xatol': 0.00001
+                                                               },
+                                )
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+        np.save(f'simplex_allvecs_{timestamp}.npy', min["allvecs"], allow_pickle=True)
+
+        f = open(f"simplex_allres_{timestamp}.txt", "a+")
+        f.write(min)
+        f.close()
+
+        return min
+
+    def run_bo_opt(self, rnd_state=11, init_pnts=3, n_iter=200):
+        # Set domain
+        bounds = {'varx': self.pbounds[0], 'vary': self.pbounds[1], 'varz': self.pbounds[2]}
+
+        # Run BO
+        optimizer = BayesianOptimization(
+            f=self.evaluate,
+            pbounds=bounds,
+            random_state=rnd_state,
+        )
+
+        #        optimizer.maximize(init_points=init_pnts, n_iter=n_iter)
+        optimizer.maximize(init_points=init_pnts,
+                           n_iter=n_iter,
+                           kappa=0.01
+                           # kappa_decay = 0.8,
+                           # kappa_decay_delay = 25
+                           )
+
+        return optimizer
+
+    def run_simplex_opt_norm(self, max_iter):
+        np.random.seed(self.seed)
+
+        # below code based on Badger implementation of simplex for the ACR
+
+        # vars init values
+        x0 = [np.random.uniform(self.pbounds[0][0], self.pbounds[0][1]),
+             np.random.uniform(self.pbounds[1][0], self.pbounds[1][1]),
+             np.random.uniform(self.pbounds[2][0], self.pbounds[2][1])
+             ]
+        # lower bounds
+        lb = [self.pbounds[0][0], self.pbounds[1][0], self.pbounds[2][0]]
+        # upper bounds
+        ub = [self.pbounds[0][1], self.pbounds[1][1], self.pbounds[2][1]]
+        # normalization coeff
+        gain = 4
+        # tolerance
+        xtol = 1e-9
+
+        # Convert (possible) list to array
+        x0 = np.array(x0)
+        lb = np.array(lb)
+        ub = np.array(ub)
+
+        x0_raw = lb + x0 * (ub - lb)
+        mu = x0_raw - gain * np.sqrt(np.abs(x0_raw))
+        sigma = np.sqrt(np.abs(mu))
+
+        x0_n = (x0_raw - mu) / sigma  # normalized x0
+
+        def _evaluate(x_n):
+            x_n = np.array(x_n)
+            x_raw = mu + sigma * x_n  # denormalization from Ocelot
+            x = (x_raw - lb) / (ub - lb)  # normalization for Badger
+            y = self.eval_simplex(x)
+
+            return y
+
+        res = optimize.fmin(_evaluate, x0_n, maxiter=max_iter, maxfun=max_iter, xtol=xtol, retall=True,
+                            full_output=True)
+
+        print(res)
+
+        return res
diff --git a/examples/pyemittance_bmad_demo.ipynb b/examples/pyemittance_bmad_demo.ipynb
new file mode 100644
index 0000000..13f3345
--- /dev/null
+++ b/examples/pyemittance_bmad_demo.ipynb
@@ -0,0 +1,648 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e9f90987-42a7-42d0-b14c-6f067a62ccf1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import os\n",
+    "import datetime \n",
+    "import scipy.constants as constants\n",
+    "from pytao import Tao\n",
+    "\n",
+    "import matplotlib\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1fb01894-da94-429f-bb24-eb1e0802c708",
+   "metadata": {},
+   "source": [
+    "# Sim setup for pytao"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "98a8a51d-78b9-4c74-ac3e-0280801a49b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "init = '-init ./tao.init -noplot'\n",
+    "tao=Tao(init)  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "55c8f2c0-8b0e-4b13-a93f-b5f5c18a9e29",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# scan from 1 to -9 kG (machine units)\n",
+    "try:\n",
+    "    tao.cmd('snparticle 1500')\n",
+    "except RuntimeError:\n",
+    "    pass\n",
+    "\n",
+    "try:\n",
+    "    tao.cmd('beamon')\n",
+    "except RuntimeError:\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ac20e4d-104b-4576-be3c-3dcfffbd744f",
+   "metadata": {},
+   "source": [
+    "For transverse emittance measurement, we need to:\n",
+    "1. vary QE04 (QUAD:IN20:525)\n",
+    "2. measure beamsize for every QE04 value at the OTR2 screen\n",
+    "3. fit the beamsize vs quad strength data to get the emittance "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90c4540c-15ac-40de-ba24-9319e904877b",
+   "metadata": {},
+   "source": [
+    "## Varying QE04 K1 from -12 to 0 1/m^2 (sim units) and getting beamsizes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "0a6658ae-d9a8-4963-96b6-8befe40f4a3c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "    4  K1                          = -1.2000000E+01 1/m^2    45  B1_GRADIENT                 =  5.4036996E+00 T/m\n",
+      "    4  K1                          = -9.0000000E+00 1/m^2    45  B1_GRADIENT                 =  4.0527747E+00 T/m\n",
+      "    4  K1                          = -6.0000000E+00 1/m^2    45  B1_GRADIENT                 =  2.7018498E+00 T/m\n",
+      "    4  K1                          = -3.0000000E+00 1/m^2    45  B1_GRADIENT                 =  1.3509249E+00 T/m\n",
+      "   10  FRINGE_TYPE                 =  None (1)               11  FRINGE_AT                   =  Both_Ends (3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# scanning values\n",
+    "quad_vals = np.linspace(-12, 0, 5)\n",
+    "# beamsizes list\n",
+    "x_sizes = []\n",
+    "y_sizes = []\n",
+    "# saving emittance predicted from bmad model\n",
+    "norm_emit_x = []\n",
+    "norm_emit_y = []\n",
+    "\n",
+    "for i in range(len(quad_vals)):\n",
+    "    try:\n",
+    "        tao.cmd(f'set ele QE04 K1={quad_vals[i]}')\n",
+    "    except RuntimeError:\n",
+    "        pass\n",
+    "    \n",
+    "    print(tao.cmd('show ele QE04')[10])\n",
+    "    \n",
+    "    # bunch statistical data\n",
+    "    stats = tao.bunch_params('OTR2')\n",
+    "    x_sizes.append(stats[\"sigma_x\"])\n",
+    "    y_sizes.append(stats[\"sigma_y\"])\n",
+    "    norm_emit_x.append(stats[\"norm_emit_x\"])\n",
+    "    norm_emit_y.append(stats[\"norm_emit_y\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "94f08abe-5829-4eea-b5ff-1e3c1afc3ded",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Beamsize (m)')"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAELCAYAAAAP/iu7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAeg0lEQVR4nO3dfZQcdZ3v8ffHQED38mgCiwlsxhBxw5olcSQx4ihxhcSjBHRzDcgSMLs5KFlED4vhZlfZddlFfLhsNgFEwQQRuXDkIVcRwaDMxcjDJGFDgkQmDIQJCIm6PBghQr73j6oJPZNJd81M/9LTPZ/XOXO661f1q/oWZPozVb/qKkUEZmZmKb2h1gWYmVnjc9iYmVlyDhszM0vOYWNmZsk5bMzMLDmHjZmZJbdXrQsYrEaMGBFjxoypdRlmZnVl1apVWyNiZM92h81ujBkzhra2tlqXYWZWVyQ92Vu7T6OZmVlyDhszM0vOYWNmZsk5bMzMLDmHjZnZUHfvZdDR2r2tozVrrxKHjZnZUDdqEtx05uuB09GaTY+aVLVN+NJnM7OhrqkFZi3NAqZ5LrRdnU03tVRtEz6yMTOzLFia50LrpdlrFYMGHDZmZgbZqbO2q6Hlguy15xjOADlszMyGuq4xmllLYdrC10+pVTFwHDZmZkPd5tXdx2i6xnA2r67aJnyBgJnZUHfcebu2NbX4AgEzM6svDhszM0vOYWNmZsk5bMzMLLmkYSNpuqQNktolLehlviQtyuevlTSpUl9JB0u6S9Jj+etBefubJf1U0kuSFpcs/yZJP5T0qKT1ki5Juc9mZrarZGEjaRiwBJgBjAdOlTS+x2IzgHH5zzzgigJ9FwArImIcsCKfBngZ+Cfg/F7K+WpEvB2YCLxH0oyq7KSZmRWS8sjmWKA9Ih6PiO3ADcDMHsvMBK6NzH3AgZIOq9B3JrAsf78MOBkgIn4fEfeShc5OEbEtIn6av98OrAZGV3dXzcysnJRhMwp4qmS6M28rsky5vodGxDMA+eshRQuSdCDwEbIjot7mz5PUJqlty5YtRVdrZmYVpAwb9dIWBZcp0rdvxUh7Ad8DFkXE470tExFXRURzRDSPHDlyIJszM7MSKcOmEzi8ZHo08HTBZcr1fTY/1Ub++lzBeq4CHouIywoub2ZmVZIybB4ExklqkjQcmA0s77HMcuCM/Kq0KcDz+amxcn2XA3Py93OA2yoVIulfgQOA8wa4T2Zm1g/J7o0WEa9Kmg/8GBgGXBMR6yWdnc+/Ergd+BDQDmwDzirXN1/1JcCNkuYCm4BZXduU9ASwPzBc0snACcALwELgUWC1JIDFEfGtVPtuZmbdKWJAQyENq7m5Odra2mpdhplZXZG0KiKae7b7DgJmZpacw8bMzJJz2JiZWXIOGzOzIe7KezaycuPWbm0rN27lyns2Vm0bDhszsyFuwugDmH/9mp2Bs3LjVuZfv4YJow+o2jb8WGgzsyFu6tgRLD5tIvOvX8Ppk4/guvs3sfi0iUwdO6Jq2/CRjZmZMXXsCE6ffASL7m7n9MlHVDVowGFjZmZkp86uu38T5047kuvu37TLGM5AOWzMzIa4rjGaxadN5HMnHLXzlFo1A8dhY2Y2xK3tfL7bGE3XGM7azuertg3frmY3fLsaM7O+8+1qzMysZhw2ZmaWnMPGzMySc9iYmVlyDhszM0vOYVMt914GHa3d2zpas3YzsyHOYVMtoybBTWe+Hjgdrdn0qEm1rMrMbFDwjTirpakFZi3NAqZ5LrRdnU03tdS4MDOz2vORTTU1tWRB03pp9uqgMTMDHDbV1dGaHdG0XJC99hzDMTMbohw21dI1RjNrKUxb+PopNQeOmZnDpmo2r+4+RtM1hrN5dS2rMjMbFHyBQLUcd96ubU0tHrcxM8NHNmZmtgc4bMzMLDmHjZmZJeewMTOz5Bw2ZmaWnMPGzMySc9iYmVlyScNG0nRJGyS1S1rQy3xJWpTPXytpUqW+kg6WdJekx/LXg/L2N0v6qaSXJC3usZ13Sno4X9ciSUq532Zm1l2ysJE0DFgCzADGA6dKGt9jsRnAuPxnHnBFgb4LgBURMQ5YkU8DvAz8E3B+L+Vcka+/a1vTq7CLZmZWUMojm2OB9oh4PCK2AzcAM3ssMxO4NjL3AQdKOqxC35nAsvz9MuBkgIj4fUTcSxY6O+Xr2z8ifhERAVzb1cfMzPaMlGEzCniqZLozbyuyTLm+h0bEMwD56yEF6uisUAcAkuZJapPUtmXLlgqrNTOzolKGTW/jIlFwmSJ9q1lH1hhxVUQ0R0TzyJEj+7k5MzPrKWXYdAKHl0yPBp4uuEy5vs/mp8a6TpE9V6CO0RXqMDOzhFKGzYPAOElNkoYDs4HlPZZZDpyRX5U2BXg+PzVWru9yYE7+fg5wW7ki8vW9KGlKfhXaGZX6mJlZdSV7xEBEvCppPvBjYBhwTUSsl3R2Pv9K4HbgQ0A7sA04q1zffNWXADdKmgtsAmZ1bVPSE8D+wHBJJwMnRMQjwKeApcAbgR/lP2Zmtocou0DLempubo62trZal2FmVlckrYqI5p7tvoOAmZkl57AxM7PkHDZmZpacw8bMzJJz2JiZWXIOGzMzS85hY2ZmyTlszMwsOYeNmZklV/F2NZJGk92b7L3AW4A/AOuAHwI/iogdSSs0M7O6VzZsJH2b7NkvPwC+THaH5X2Bt5E97XKhpAUR0Zq6UDMzq1+Vjmy+FhHremlfB9yc35H5iOqXZWZmjaRs2OwmaErnbye7Y7OZmdluFbpAQNKHJa2R9FtJL0h6UdILqYszM7PGUPR5NpcBHwUeDj+TwMzM+qjopc9PAescNGZm1h9Fj2wuAG6XdA/wSldjRHw9SVVmZtZQiobNxcBLZJc9D09XjpmZNaKiYXNwRJyQtBIzM2tYRcdsfiLJYWNmZv1SNGzOAe6Q9Adf+mxmZn1V6DRaROyXuhAzM2tcZY9sJI2pMF/5jTrNzMx2q9KRzVckvQG4DVgFbCG7Iu1I4HjgA8AXgc6URZqZWX2rdG+0WZLGA58APgkcBmwDfgncDlwcES8nr9LMzOpaxTGbiHgEWLgHajEzswblJ3WamVlyDhszM0vOYWNmZskVfZ6NJJ0u6Qv59BGSjk1bmpmZNYqiRzaXA+8GTs2nXwSWVOokabqkDZLaJS3oZb4kLcrnr5U0qVJfSQdLukvSY/nrQSXzLsyX3yDpxJL2UyU9nG/jDkkjCu63mZlVQdGwmRwR5wAvA0TE76hw92dJw8gCaQYwHjg1v4y61AxgXP4zD7iiQN8FwIqIGAesyKfJ588GjgamA5dLGiZpL+A/gOMjYgKwFphfcL/NzKwKiobNH/MACABJI4EdFfocC7RHxOMRsR24AZjZY5mZwLWRuQ84UNJhFfrOBJbl75cBJ5e03xARr0REB9Cer0f5z59IErA/8HTB/TYzsyooGjaLgFuAQyRdDNwL/FuFPqPInvDZpTNvK7JMub6HRsQzAPnrIeXWFRF/BD4FPEwWMuOBqyvUbmZmVVQobCLiu2RP6/x34Bng5Ii4qUI39baqgssU6Vtoe5L2JgubicBbyE6jXdjrCqR5ktoktW3ZsqXC5szMrKiiV6NdDewbEUsiYnFE/FLSRRW6dQKHl0yPZtfTV7tbplzfZ/NTbeSvz1VY1zEAEbExIgK4EZjaW8ERcVVENEdE88iRIyvsnpmZFVX0NNqJwFJJZ5S0nVShz4PAOElNkoaTDd4v77HMcuCM/Kq0KcDz+amxcn2XA3Py93PIbhLa1T5b0j6SmsguOngA2AyMz8eZAD5Idm+3qrryno2s3Li1W9vKjVu58p6N1d6UmVndKRo2zwEtwCxJS/IrvHo7bbVTRLxKdtXXj8k+3G+MiPWSzpZ0dr7Y7cDjZIP53wQ+Xa5v3ucS4IOSHiMLjkvyPuvJjloeAe4AzomI1yLiaeCfgVZJa8mOdCqNN/XZhNEHMP/6NTsDZ+XGrcy/fg0TRh9Q7U2ZmdUdZWeWKiwkrYmIifn7i8g+5A+LiLemLa92mpubo62trU99ugLm9MlHcN39m1h82kSmjvVXesxs6JC0KiKae7YXPbLZeforIi4iu1DgiapU1kCmjh3B6ZOPYNHd7Zw++QgHjZlZrujVaF/sMf2DiJiWpqT6tXLjVq67fxPnTjuS6+7ftMsYjpnZUFX2eTaS7o2I4yS9SPdLjwVEROyftLo60nUKrevU2ZSxb+42bWY2lJU9somI4/LX/SJi/5Kf/Rw03a3tfL5bsEwdO4LFp01kbefzNa7MzKz2il4gMBbojIhXJL0fmEB2m5n/TlpdDfXnAgEzs6FuoBcIfB94TdKRZLd6aQKur2J9ZmbWwIqGzY78uy+nAJdFxGeBw9KVZWbWf/6S9eDTl7s+n0r2jf0f5G17pynJzGxg/CXrwafs1WglzgLOBi6OiI78djDXpSvLzKz/ui7Q8ZesB49CYRMRjwDnlkx3kN8mxsxsMCr9kvW504500NRY0bs+f1jSGkm/lfSCpBclvZC6ODOz/vKXrAeXoqfRLgM+CjwcRa6VNjOroSeWX8zSh97E4k/8zc4vWS/97nd4yzHbGHPSwlqXNyQVvUDgKWCdg8bM6sHaHWNZsvcipr7hEQCmvuERluy9iLU7xta4sqGr6JHNBcDtku4BXulqjIivJ6nKzGwATjp5NvzlW+CmM6F5LrRdzd6zl3FSU0utSxuyiobNxcBLwL7A8HTlmJlVSVNLFjStl0LLBdm01UzRsDk4Ik5IWomZWTV1tELb1VnQtF0NTe914NRQ0TGbn0hy2JhZfehozU6hzVoK0xZmrzedmbVbTRQNm3OAOyT9wZc+m9mgt3l1FjBdRzJNLdn05tW1rGpIK/qlzv1SF2JmVjXHnbdrW1OLT6PVUNExGyQdBIwju0gAgIjwMamZmVVUKGwk/S3wGWA08BAwBfgF4EdDm5lZRUXHbD4DvAt4MiKOByYCW5JVZWZmDaVo2LwcES8DSNonIh4FjkpXlpmZNZKiYzadkg4EbgXukvQ74OlURZmZWWMpejXaKfnbiyT9FDgAuCNZVWZm1lD6cjXaccC4iPi2pJHAKKAjWWVmZtYwij7P5ovA54EL86a98ZM6zcysoKIXCJwCnAT8HiAingb8RU8zMyukaNhsz59lEwCS/iRdSWZm1miKhs2Nkr4BHCjp74CfAN9MV5aZmTWSolejfVXSB4EXyL5f84WIuCtpZWZm1jCKHtkQEXdFxD8Al5Ad2VQkabqkDZLaJS3oZb4kLcrnr5U0qVJfSQdLukvSY/nrQSXzLsyX3yDpxJL24ZKukvQrSY9K+ljR/TYzs4ErGzaSpkj6maSbJU2UtA5YBzwraXqFvsOAJcAMYDxwqqTxPRabQXZzz3HAPOCKAn0XACsiYhywIp8mnz8bOBqYDlyerwdgIfBcRLwtX9895Wo3M7PqqnRksxj4N+B7wN3A30bEnwItwL9X6Hss0B4Rj0fEduAGYGaPZWYC10bmPrIxocMq9J0JLMvfLwNOLmm/ISJeiYgOoD1fD8Anu+qNiB0RsbVC7WZmVkWVwmaviLgzIm4Cfp0HAvm90SoZBTxVMt2ZtxVZplzfQyPimbyOZ4BDyq0rv80OwJckrZZ0k6RDC9RvZmZVUilsdpS8/0OPeVGhr3pp69lnd8sU6Vt0e3uRPRrh5xExiezRCF/tdQXSPEltktq2bPFNrc3MqqVS2Pxl12OggQn5+67pd1To2wkcXjI9ml1v3rm7Zcr1fTY/1Ub++lyFdf0G2AbckrffBEyiFxFxVUQ0R0TzyJEjK+yemZkVVTZsImJYROwfEftFxF75+67pvSus+0FgnKQmScPJBu+X91hmOXBGflXaFOD5/NRYub7LgTn5+znAbSXtsyXtI6mJ7KKDB/Ivo/5f4P35ch8AHqlQu5mZVVHhG3H2VUS8Kmk+8GNgGHBNRKyXdHY+/0rgduBDZIP524CzyvXNV30J2ZdM5wKbgFl5n/WSbiQLkleBcyLitbzP54HvSLqM7KFvZ6XabzMz25WyP/ytp+bm5mhra6t1GWZmdUXSqoho7tle+EudZmZm/eWwMTOz5Bw2Vhv3XgYdrd3bOlqzdjNrOA4bq41Rk+CmM18PnI7WbHpUr1elm1mdS3Y1mllZTS0wa2kWMM1zoe3qbLqppcaFmVkKPrKx2mlqyYKm9dLs1UFj1rAcNlY7Ha3ZEU3LBdlrzzEcM2sYDhurja4xmllLYdrC10+pOXDMGpLDxmpj8+ruYzRdYzibV9eyKjNLxBcIWG0cd96ubU0tHrcxa1A+sjEzs+QcNmZmlpzDxszMknPYmJlZcg4bMzNLzmFjZmbJOWzMzCw5h42ZmSXnsDEzs+QcNmZmlpzDxszMknPYmJlZcg4bMzNLzmFjZmbJOWzMzCw5h42ZmSXnsDEzs+QcNmZmlpzDxszMknPYmJlZcg4bMzNLLmnYSJouaYOkdkkLepkvSYvy+WslTarUV9LBku6S9Fj+elDJvAvz5TdIOrGX7S2XtC7FvlrfXHnPRlZu3NqtbeXGrVx5z8YaVWRmKSULG0nDgCXADGA8cKqk8T0WmwGMy3/mAVcU6LsAWBER44AV+TT5/NnA0cB04PJ8PV31fBR4qfp7av0xYfQBzL9+zc7AWblxK/OvX8OE0QfUuDIzSyHlkc2xQHtEPB4R24EbgJk9lpkJXBuZ+4ADJR1Woe9MYFn+fhlwckn7DRHxSkR0AO35epD0P4DPAf+aYD+tH6aOHcHi0yYy//o1fP3ODcy/fg2LT5vI1LEjal2amSWQMmxGAU+VTHfmbUWWKdf30Ih4BiB/PaTA9r4EfA3YVq5gSfMktUlq27JlS7lFrQqmjh3B6ZOPYNHd7Zw++QgHjVkDSxk26qUtCi5TpG+h7Uk6BjgyIm6p0J+IuCoimiOieeTIkZUWtwFauXEr192/iXOnHcl192/aZQzHXucxLqt3KcOmEzi8ZHo08HTBZcr1fTY/1Ub++lyFdb0beKekJ4B7gbdJ+lm/9siqpmuMZvFpE/ncCUftPKXmwOmdx7is3qUMmweBcZKaJA0nG7xf3mOZ5cAZ+VVpU4Dn81Nj5fouB+bk7+cAt5W0z5a0j6QmsosOHoiIKyLiLRExBjgO+FVEvD/FDltxazuf7zZG0zWGs7bz+RpXNjh5jMvq3V6pVhwRr0qaD/wYGAZcExHrJZ2dz78SuB34ENlg/jbgrHJ981VfAtwoaS6wCZiV91kv6UbgEeBV4JyIeC3V/tnAnP2+sbu0TR07wh+eZZSOcZ077Uj/t7K6oohKQyFDU3Nzc7S1tdW6DLOduk6dnT75CK67f5OPbGxQkrQqIpp7tvsOAmZ1wGNcVu8cNmZ1wGNcVu98Gm03fBrNzKzvfBrNzMxqxmFjZmbJOWzMzCw5h42ZmSXnsDEzs+QcNmZmlpzDxszMknPYmJlZcg4bMzNLzmFjZmbJOWzMzCw5h42ZmSXnsDEzs+QcNmZmlpzDxszMknPYmNWDey+DjtbubR2tWbtZHXDYmNWDUZPgpjNfD5yO1mx61KRaVmVW2F61LsDMCmhqgVlLs4BpngttV2fTTS01LsysGB/ZmNWLppYsaFovzV4dNFZHHDZm9aKjNTuiabkge+05hmM2iDlszOpB1xjNrKUwbeHrp9QcOFYnHDZm9WDz6u5jNF1jOJtX17Iqs8J8gYBZPTjuvF3bmlo8bmN1w0c2ZmaWnMPGzMySc9iYmVlyDhszM0vOYWNmZskpImpdw6AkaQvwZD+7jwC2VrGcWmqUfWmU/QDvy2DVKPsy0P34s4gY2bPRYZOApLaIaK51HdXQKPvSKPsB3pfBqlH2JdV++DSamZkl57AxM7PkHDZpXFXrAqqoUfalUfYDvC+DVaPsS5L98JiNmZkl5yMbMzNLzmFjZmbJOWyqRNIsSesl7ZDUXNL+QUmrJD2cv06rZZ1F7G5f8nkXSmqXtEHSibWqsT8kHSPpPkkPSWqTdGytaxoISX+f/39YL+nSWtczUJLOlxSSRtS6lv6Q9BVJj0paK+kWSQfWuqa+kjQ9/zfVLmlBNdftsKmedcBHgZ5Ps9oKfCQi3gHMAb6zpwvrh173RdJ4YDZwNDAduFzSsD1fXr9dCvxzRBwDfCGfrkuSjgdmAhMi4mjgqzUuaUAkHQ58ENhU61oG4C7gLyJiAvAr4MIa19Mn+e/yEmAGMB44Nf+drwqHTZVExC8jYkMv7Wsi4ul8cj2wr6R99mx1fbO7fSH7cLshIl6JiA6gHaino4MA9s/fHwA8XWbZwe5TwCUR8QpARDxX43oG6n8DF5D9P6pLEXFnRLyaT94HjK5lPf1wLNAeEY9HxHbgBrLf+apw2OxZHwPWdH1A1KFRwFMl0515W704D/iKpKfIjgTq6i/PHt4GvFfS/ZLukfSuWhfUX5JOAjZHxH/VupYq+iTwo1oX0UdJf7/9pM4+kPQT4E97mbUwIm6r0Pdo4MvACSlq66t+7ot6aRtUf4mW2y/gA8BnI+L7kv4ncDXwV3uyvr6osC97AQcBU4B3ATdKemsM0u8yVNiX/8Ug+b2opMjvjaSFwKvAd/dkbVWQ9PfbYdMHEdGvDyZJo4FbgDMiYmN1q+qffu5LJ3B4yfRoBtmpqHL7Jela4DP55E3At/ZIUf1UYV8+Bdych8sDknaQ3UBxy56qry92ty+S3gE0Af8lCbJ/U6slHRsRv96DJRZS6fdG0hzgw8AHBmvwl5H099un0RLLr0j5IXBhRPy8xuUM1HJgtqR9JDUB44AHalxTXzwNvC9/Pw14rIa1DNStZPuApLcBw6nDOw5HxMMRcUhEjImIMWQfeJMGY9BUImk68HngpIjYVut6+uFBYJykJknDyS4GWl6tlfsOAlUi6RTgP4GRwH8DD0XEiZL+kWxsoPSD7YTBPKC7u33J5y0kOx/9KnBeRNTNeWlJxwH/QXZE/zLw6YhYVduq+if/MLgGOAbYDpwfEXfXtKgqkPQE0BwRdRecktqBfYDf5E33RcTZNSypzyR9CLgMGAZcExEXV23dDhszM0vNp9HMzCw5h42ZmSXnsDEzs+QcNmZmlpzDxszMknPYmJlZcg4bM9sjJJ0s6ZuSbpNUF7ensepx2FhDkzQ6/3B7TNLjkhZX667bki6SdH4v7YdKuj7f3ipJv8i/KFu1bUla2c/1HCjp02XmvzG/seewfPoaSc9JWtfLst+Q9J6i246IWyPi74AzgY9LGi6pVZJvmzUEOGysYSm72dbNwK0RMY7s9jpvJOFzbPJt3gq0RsRbI+KdZLf92OV288r063cwIqb2s8QDgd2GDdndIW6OiNfy6aVkzy7qzWSyW+n31T8CS/Lb2K8APt6PdVidcdhYI5sGvBwR3wbIP0A/C5wh6S9K/1rPnxJ5Ucn0rflRyXpJ80raF+ZPMvwJcNRutrk9Iq7saoiIJyPiP/P+YyT9UtLlwGrg8P5sS9JL+evpkh5Q9vTRb5QckXRt55v5eu+U9EbgEmBsvvxXeqn/E8DOu35HRCvw254LSfpz4FcR8Vq+rUclfUvSOknflfRXkn6eH1Eem/eRpC8DP4qI1fmqbs23aQ3OYWON7Gig273PIuIF4Akq3/H8k/lRSTNwrqQ3S+o6SplI9iTT3p4hczRZiJRzFHBtREyMiCf7u638A//jwHvyp4++RvcP7nFkRxBHk93j7mPAAmBjRBwTEf/QY33DgbdGxBMV6ofsaY53lEwfSXbfuQnA24HTgOOA88keIQDw92SPdPhrSV33DFvX275Z4/G5UmtkovfncfT23I6ezi0ZZzmc7IN7CnBL1x19JVW8I66kJWQfutsjoutD9cmIKD391N9tfQB4J/Bgfnv+NwKlN3jtiIiH8vergDHAvWXKHUEWSkWcCJzVY1sP57WuB1ZEREh6ON8uEbEIWFS6kvzIaLuk/SLixYLbtjrksLFGtp7sr/mdJO0PHEp2Z97SI/t9S5Z5P9lf4O+OiG2SflYyv9Kda7ttMyLOkTQCaCtZ5vdV2paAZRGxuyeOlj4R9jWyMCrnDyXb3v1GpTcBB5Y87rzntnaUTO+g8ufMPmR34bYG5tNo1shWAG+SdAZAPp7xNWAx8GvgkPyU1T5kD7zqcgDwu/zD/+1kRxkArcAp+RVb+wEf6WWbdwP7Knu4WZc3lalxINtaQXZK6pB8/w6W9GdltgXwIrBfbzMi4nfAMEmVAud44KcVlilE0puBLRHxx2qszwYvh401rPxJiaeQfSA/RnY0syMiLs4/3P4FuB/4AfBoSdc7gL0krQW+RH7FVT6o/X+Ah4DvA/9vN9s8GXifpA5JDwDLyB6q1ZuBbOsRsiu77sz73wUcVuG/yW+An+cD+b1dIHAn2Wk/ACR9D/gFcJSkTklz2XW8ZiCOB26v0rpsEPPzbGzIkDQV+B7w0Xp9aFpqkiYCn4uIvymzzGpgcjWORiTdTPYU2w0DXZcNbg4bM+tG0ifJxoJeq7jwwLYzHJgdEdem3I4NDg4bMzNLzmM2ZmaWnMPGzMySc9iYmVlyDhszM0vOYWNmZsk5bMzMLDmHjZmZJeewMTOz5P4/pIO3LVVRXg0AAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(quad_vals, x_sizes, marker=\"x\", linewidth=0)\n",
+    "plt.plot(quad_vals, y_sizes, marker=\"x\", linewidth=0)\n",
+    "plt.xlabel(r\"Quad Gradient (1/m$^2$)\")\n",
+    "plt.ylabel(\"Beamsize (m)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "2812030a-9148-4ec2-85f9-b757cad2621b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f60bfcc41d0>]"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(np.array(norm_emit_x)/1e-6)\n",
+    "plt.plot(np.array(norm_emit_y)/1e-6)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fd7f8db1-1d00-4abc-a521-1373e40de788",
+   "metadata": {},
+   "source": [
+    "# Getting emittance using pyemittance package"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "d77edc66-660e-49f4-9baf-5c9fd12d5149",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# the sim quad vals are in T/m, but we need them in kG (set up to take kG since that's the machine unit)\n",
+    "# there are functions in pyemittance to do this\n",
+    "from pyemittance.optics import get_quad_field\n",
+    "\n",
+    "quad_field_kG = get_quad_field(quad_vals)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "140f873c-2cf5-41a9-b39d-339babbea72e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# no error on sim measurement (but this would be non-zero on the machine)\n",
+    "x_sizes_err = np.asarray(x_sizes)*0\n",
+    "y_sizes_err = np.asarray(y_sizes)*0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 65,
+   "id": "8ee4c20a-28db-4be2-85cf-67ed8ce73dfb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEGCAYAAACzYDhlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAA2MElEQVR4nO3dd5gUVdbH8e9hGKIiGUkKSlCSgICwBAVEQDKKBFdAVJLsurqisq5iXHwVswhiRCVLVGCJAqKgkhEliYADSpKgMMCE8/5xC3YcJvQw3VPdM+fzPDzdXV23+lcM9JmqunWvqCrGGGNMKOXyO4Axxpjsz4qNMcaYkLNiY4wxJuSs2BhjjAk5KzbGGGNCLrffAcJV8eLFtUKFCn7HMMaYiLJmzZpDqloi+XIrNqmoUKECq1ev9juGMcZEFBHZndJyO41mjDEm5KzYGGOMCTkrNsYYY0LOrtlkQFxcHDExMZw6dcrvKCYA+fLlo1y5ckRHR/sdxZgcz4pNBsTExHDxxRdToUIFRMTvOCYNqsrhw4eJiYmhYsWKfscxJsez02gZcOrUKYoVK2aFJgKICMWKFbOjUGPChBWbDLJCEznsZ2VM+LBiE2Ld31pJ97dW+h3DGGN8ZcUmwogId9xxx7nX8fHxlChRgvbt2/uYKussXbqUr776yu8YxmRLofzl2IpNCM1ct5d1e47y9U+/0fi5JcxctzfT2yxYsCDfffcdsbGxACxcuJCyZctmersXIj4+Pss/04qNMaERiu+rpKzYhMjMdXsZNn0TZxISAdh7NJZh0zcF5QfYtm1b5syZA8DEiRPp2bPnufdOnDhBv379qF+/PnXq1GHWrFkA7Nq1i6ZNm1K3bl3q1q177gv7l19+oVmzZtSuXZsaNWrwxRdfAHDRRRed2+Ynn3xC3759Aejbty8PPPAAzZs35+GHH+bHH3+kTZs2XHvttTRt2pQtW7acW2/QoEE0b96cK664gmXLltGvXz+uvvrqc9sCWLBgAY0aNaJu3bp069aNP/74A3DDBQ0fPpy6detSs2ZNtmzZwq5duxgzZgwvv/wytWvX5osvvmDq1KnUqFGDa665hmbNmmX679aYnCiU31dnWbEJkRfmbyU2LuFPy2LjEnhh/tZMb7tHjx5MmjSJU6dOsXHjRq677rpz7z377LO0aNGCb7/9ls8//5yhQ4dy4sQJSpYsycKFC1m7di2TJ0/m73//OwATJkygdevWrF+/ng0bNlC7du10P3/btm0sWrSIF198kf79+/P666+zZs0aRo4cyeDBg8+td+TIEZYsWcLLL79Mhw4duP/++9m8eTObNm1i/fr1HDp0iGeeeYZFixaxdu1a6tWrx0svvXSuffHixVm7di2DBg1i5MiRVKhQgYEDB3L//fezfv16mjZtylNPPcX8+fPZsGEDs2fPzvTfrTE5USi/r86y+2xCZN/R2Awtz4hatWqxa9cuJk6cyM033/yn9xYsWMDs2bMZOXIk4Lpr79mzhzJlyjBkyBDWr19PVFQU27ZtA6B+/fr069ePuLg4OnfuHFCx6datG1FRUfzxxx989dVXdOvW7dx7p0+fPve8Q4cOiAg1a9akVKlS1KxZE4Dq1auza9cuYmJi+P7772ncuDEAZ86coVGjRufad+3aFYBrr72W6dOnp5ilcePG9O3bl9tuu+3c+saYjAnl99VZVmxCpEzh/OxN4QdVpnD+oGy/Y8eOPPjggyxdupTDhw+fW66qTJs2japVq/5p/SeeeIJSpUqxYcMGEhMTyZcvHwDNmjVj+fLlzJkzhzvuuIOhQ4fSu3fvP3UbTn6vSsGCBQFITEykcOHCrF+/PsWMefPmBSBXrlznnp99HR8fT1RUFK1atWLixIlpto+Kikr1+tCYMWP4+uuvmTNnDrVr12b9+vUUK1YsxXWNMSkL9fcV2Gm0kBnauir5o6P+tCx/dBRDW1dNpUXG9OvXj8cff/zc0cJZrVu35vXXX0dVAVi3bh0Ax44do3Tp0uTKlYuPPvqIhAR3yLx7925KlizJPffcw1133cXatWsBKFWqFD/88AOJiYnMmDEjxQyFChWiYsWKTJ06FXCFbsOGDQHvQ8OGDfnyyy/ZsWMHACdPnjx3xJWaiy++mN9///3c6x9//JHrrruOp556iuLFi/Pzzz8H/PnGGCfU31dgxSZkOtcpy4iuNckT5f6KyxbOz4iuNelcJzg9x8qVK8d999133vLHHnuMuLg4atWqRY0aNXjssccAGDx4MOPGjaNhw4Zs27bt3NHJ0qVLqV27NnXq1GHatGnntvncc8/Rvn17WrRoQenSpVPNMX78eN59912uueYaqlevfq5DQiBKlCjBBx98QM+ePalVqxYNGzY818EgNR06dGDGjBnnOggMHTqUmjVrUqNGDZo1a8Y111wT8OcbY5xQf18ByNnfgM2f1atXT5NPnvbDDz9w9dVXZ2g7Z/usTx7QKJ01TShcyM/MGHPhRGSNqtZLvtyu2YSYFRljjLHTaMYYY7KAFRtjjDEhF9JiIyJtRGSriOwQkUdSeF9E5DXv/Y0iUje9tiJSVEQWish277GIt7yYiHwuIn+IyBtJ1i8gInNEZIuIbBaR50K5z8YYY84XsmIjIlHAKKAtUA3oKSLVkq3WFqjs/ekPjA6g7SPAYlWtDCz2XgOcAh4DHkwhzkhVvQqoAzQWkbZB2UljjDEBCeWRTQNgh6ruVNUzwCSgU7J1OgEfqrMKKCwipdNp2wkY5z0fB3QGUNUTqroCV3TOUdWTqvq59/wMsBYoF9xdNcYYk5ZQFpuyQNI77GK8ZYGsk1bbUqr6C4D3WDLQQCJSGOiAOyJK6f3+IrJaRFYfPHgw0M1mqWBNMVChQgUOHTqU6XWMMSYQoSw2KU2TmPymntTWCaRtxsKI5AYmAq+p6s6U1lHVsapaT1XrlShRIjMfFzLhNMWAMcYEKpTFJgYon+R1OWBfgOuk1Xa/d6oN7/FAgHnGAttV9ZUA1w+On7+BL150j0GS1hQDv/32G507dz53R/7GjRsBOHz4MDfddBN16tRhwIABJL2Z9+OPP6ZBgwbUrl2bAQMGnBvKxhiTw+xcDrP/HtTvq7NCeVPnt0BlEakI7AV6AL2SrTMbGCIik4DrgGOq+ouIHEyj7WygD/Cc95ju+Cgi8gxwCXB3pvfqrHmPwK+b0l7n9HHY/x1oIkguKFUD8hZKff1La0Lb9DvL9ejRg6eeeor27duzceNG+vXrd24emuHDh1OnTh1mzpzJkiVL6N27N+vXr+fJJ5+kSZMmPP7448yZM4exY8cC7g77yZMn8+WXXxIdHc3gwYMZP348vXv3DvivwhiTDexeBR91ct9XGydDn0+hfIOgbT5kxUZV40VkCDAfiALeU9XNIjLQe38MMBe4GdgBnATuTKutt+nngCkichewBzg3vr2I7AIKAXlEpDNwE3AceBTYAqz1RjN+Q1XfCdW+n3PqmPvBgXs8dSztYhOgtKYYWLFiBdOmTQOgRYsWHD58mGPHjrF8+fJzw/S3a9eOIkWKALB48WLWrFlD/fr1AYiNjaVkyYAvgxljsoslT/3v+yohDnZ9ERnFBkBV5+IKStJlY5I8V+DeQNt6yw8DLVNpUyGVKCldA8qcAI5A+PkbGNcREs5AVB645Z2g/fDSmmIgubPTBSSdNiDp+n369GHEiBFByWWMiUBrP4LdX4J4Iz9H5YEKTYP6ETaCQCiVbwB9ZkOLR91jEH9LSG2KgWbNmjF+/HjAjehcvHhxChUq9Kfl8+bN48iRIwC0bNmSTz75hAMH3KWv3377jd27dwctpzEmzO1cBp/9A65sAX0/C8n3FdhAnKFXvkHQf2iQ+hQDTzzxBHfeeSe1atWiQIECjBvnbkkaPnw4PXv2pG7dulx//fVcdtllAFSrVo1nnnmGm266icTERKKjoxk1ahSXX3550DMbY8LMwW0w5Q4oVhm6fQD5LoHL/xKSj7IpBlIRrCkGjL/sZ2ZMKk4cgndawpkTcPdiKBKcXzBtigFjjDFO3CmYdDv8/iv0nRO0QpMWKzbGGJOTqMLsIfDzKnfqrNx5ByEhYR0EMshOO0YO+1kZk4Klz8GmqdDycajeJcs+1opNBuTLl4/Dhw/bl1gEUFUOHz5Mvnz5/I5iTPjYOAWWPQe1b4cmD2TpR9tptAwoV64cMTExhOsgnebP8uXLR7lyNsC3MQDsXgmz7nX3z7R/BVK47y6UrNhkQHR0NBUrVvQ7hjHGZMzhH2FSLyh8Gdz2IeTOk+UR7DSaMcZkZ7FHYMJt7nmvKVCgqC8x7MjGGGOyq/gzMPkOOLoHes+CYlf6FsWKjTHGZEeq8Nn9bkDNLmNDNjJAoOw0WrBt/S8seiIk80EYY0zAVrwM6z+G6x+Ga7r7ncaObIJq91cwsQegsGpMSAazM8aYdG2eCYufhBq3wg3D/E4D2JFNcO1Z+b/n8afc4asxxmSlmNUwYwCUvw46jcryLs6psWITTBWaQu6zNxEqFCrraxxjTA5zZLc7u3LxpdBjAkSHz03NVmyCaOahstx2ahivx3XmOAU5tvgliD/tdyxjTE5w6hhM6O56oPWaCgWL+53oT6zYBMnMdXsZNn0T38RX4sWE27jvzGAuOb6VbZPC43ypMSYbS4iHqXfC4e3Q/UMoUcXvROexYhMkL8zfSmxcwrnXnyfWYXx8SyrteA92rfAxmTEmW1OFeUPhx8XQ/mW44ga/E6XIik2Q7Dsae96yZ+NvZ3diSZgx0B3iGmNMsK0aDavfg8b/gLq9/U6TKis2QVKmcP7zlp0kH//J9wAc3wfzHvYhlTEmW9syF+b/C67uAC2H+50mTVZsgmRo66rkj47607L80VG0a9sBmj0IGya6vu/GGBMM+9bDtLugTB03QkCu8P46D+90EaRznbKM6FqTsoXzI0DZwvkZ0bUmneuUhWZDoUxd+OwfbhpWY4zJjOP7XBfnAsWg5yTIU8DvROkSmwgsZfXq1dPVq1cHb4OHtsOYplChMdz+SdjcaGWMiTCn/4D328JvP8Fd86FUdb8T/YmIrFHV8+aatiObrFK8Mtz0NOxYBN++43caY0wkSkyAaXfD/u+g2/thV2jSYsUmK9W/GyrdCAsec0c6xhiTEQseg23zoO3zULmV32kyxIpNVhJxYxVF54Pp90BCnN+JjDGR4tt3YNUouG4QNLjH7zQZZsUmq118KXR4Ffatg+Uv+J3GGBMJti+CuQ9B5dbQ+lm/01wQKzZ+qNYJrukFy0fCz9/6ncYYE872fw9T+0LJanDru5ArKt0m4ciKjV/aPudGhZ7R3/UuMcaY5H7fDxNugzwFoddkyHux34kuWEiLjYi0EZGtIrJDRB5J4X0Rkde89zeKSN302opIURFZKCLbvcci3vJiIvK5iPwhIm8k+5xrRWSTt63XRMKg33G+S6DLGNd9ccG//U5jjAk3Z07CpJ5w8jD0mgSXRPaUJSErNiISBYwC2gLVgJ4iUi3Zam2Byt6f/sDoANo+AixW1crAYu81wCngMeDBFOKM9rZ/9rPaBGEXM69CY2j8d1jzvptO2hhjABITYeZA2LsWbnnHjRIQ4UJ5ZNMA2KGqO1X1DDAJ6JRsnU7Ah+qsAgqLSOl02nYCxnnPxwGdAVT1hKquwBWdc7ztFVLVleruYP3wbJuw0PxRKFUTZg+BE4f8TmOMCQdLnobvZ8FNz8BV7fxOExShLDZlgZ+TvI7xlgWyTlptS6nqLwDeY8kAcsSkkwMAEekvIqtFZPXBgwfT2WyQ5M4LXce6UaE/vc8NF26MybnWfQwrXoJr74RG9/qdJmhCWWxSui6S/Js0tXUCaRvMHG6h6lhVraeq9UqUKHGBH3cBSlVzI7Zu+cz9QzPG5Ew/LXe/dF7RHG5+IVsNaxXKYhMDlE/yuhywL8B10mq73zs1dvYU2YEAcpRLJ4f/Gg6GCk3hv4+4TgPGmJzl0HaY/FcoVgluGwdR0X4nCqpQFptvgcoiUlFE8gA9gNnJ1pkN9PZ6pTUEjnmnxtJqOxvo4z3vA8xKK4S3vd9FpKHXC613em18kSsXdB4NEuUmW0tMSL+NMSZ7OHEYxneDqDzQa4rrrZrNhKzYqGo8MASYD/wATFHVzSIyUEQGeqvNBXYCO4C3gcFptfXaPAe0EpHtQCvvNQAisgt4CegrIjFJerANAt7xPudHYF5IdjqzCpeHdiPh51Xw5St+pzHGZIX40zCpF/z+C/SYCEUu9ztRSNgUA6kI+hQDgVKFT+6EHz6Fe5ZA6WuyPoMxJmuowvT+sGkK3Po+1Ojqd6JMsykGIoUItHsJCpaAafdAXKzfiYwxobLs/1yhafFYtig0abFiE44KFIXOb8KhrbDoSb/TGGNCYeMUWDrCjZPY9J9+pwk5Kzbh6soWcN1A+Ho0/LjE7zTGmGDaswpm3QuXN3GjwGejLs6psWITzm58AopXgZmD4eRvfqcxxgTDbztdh4BLykP3jyB3Hr8TZQkrNuEsOj90fRtOHIS5KQ35ZoyJKLFHYPxtoIlw+1R3yjyHsGIT7srUhhuGwXfTYONUv9MYYy5U/BmYfAcc2QU9JkCxK/1OlKXSLTYi0khERnlTABwUkT0iMldE7hWR7HfnUThq/A8ofx3M+Scci0l3dWNMmFGFOffDri+g0xtw+V/8TpTl0iw2IjIPuBt3c2UboDRuyP9/A/mAWSLSMdQhc7yo3NDlLdAEmDnIDT9ujIkcX77ixj1s9hBc08PvNL7Inc77d6hq8nHv/wDWen9eFJHiIUlm/qxoRWgzAmb/zfVQy0ajwRqTrW2eCYuegBq3QvN/+Z3GN2ke2SQvNCJSyJsps6iIFE1pHRNCde6Aqje7e2/2f+93GmNMemLWwIwBUK4BdBqVI7o4pyagDgIiMkBE9gMbgTXeHx/GcsnhRKDDa5CvkBviIv6034mMMak5ugcm9oCLSkHPiRCdz+9Evgq0N9qDQHVVraCqFb0/V4QymEnFRSWg4xuwfxN8/h+/0xhjUnLqOEzo7n4hvH0qFLSrDYEWmx+Bk6EMYjKgahu4ti98+Srs/srvNMaYpBLi3WC6h7ZB9w+hRFW/E4WF9DoInDUM+EpEvgbOnbtR1b+HJJVJ303Pws5lMH0ADPrSnVozxvhLFeY9BDsWuVPeV9zgd6KwEeiRzVvAEmAV/7tmsyZUoUwA8l4EXcfC8Rg3u6cxxn9fj4HV70Lj++DaPumvn4MEemQTr6oPhDSJybjyDaDpg7D8eajSBqrZLU/G+GbrPPjvMLi6A7R8wu80YSfQI5vPRaS/iJRO3vXZ+Oz6h6B0bfj0Pvj9V7/TGJMz/bIBPrnLDS/VZayb5t38SaB/I73wrttgXZ/DS1S0G6wzLhZmDXHnjI0xWef4PpjQA/IXgZ6TIE8BvxOFpYCKTZLuzhWt63MYKlEFbnoadix054uNMVnj9B+ui/Pp49BrMlx8qd+JwlZ6Y6M1Sef9QiJSI7iRzAWpfzdc2RLm/xsO7fA7jTHZX2ICTL8H9n8Ht74Pl9pXYVrSO7K5RUS+EpHHRaSdiDQQkWYi0k9EPgI+A/JnQU6THhE3HEZ0PvcfICHO70TGZG8LH4etc6Ht81DlJr/ThL30xka7H2gH/AJ0A54GHgAqA2+pajNV/TbkKU1gCpWG9q/AvrWwfKTfaYzJvr59F1a+4aZub3CP32kiQrpdn1X1CPC298eEu+qdYWsPWP4CVG4F5er5nciY7GXHIpg7FCq3htY2ZFSgrH9ednTz81CojBus88wJv9MYk33s/x6m3gklq8Gt70KuKL8TRQwrNtlRvkugyxj4bScs+LffaYzJHv444HqeRReAXpMg78V+J4ooVmyyqwpN4C9/g9XvwbYFfqcxJrLFxbrpAk4ecoXmknJ+J4o4gc5nU0BEHhORt73XlUWkfWijmUxr8W8oWR1m3QsnbI47Yy5IYiLMGAh717obqMvU8TtRRAr0yOZ93GjPjbzXMcAzIUlkgid3XrjlbTh11A1nY6MLGJNxnz8D3890N05fbb9jX6hAi82Vqvo8EAegqrFAzp3fNJKUqg4tH4ctn8H6CX6nMSayrPsYvnjRzR/VaIjfaSJaoMXmjIjkBxRARK4kybw2Jsw1vBcqNIV5D8ORXX6nMSYy/LTcnRG4ojncPNLdOG0uWKDF5gngv0B5ERkPLAYeSq+RiLQRka0iskNEzpt0RZzXvPc3ikjd9Np6I04vFJHt3mORJO8N89bfKiKtkyzvKSKbvM/4r4jkrDlac+WCzm+6/ywzBrphNowxqTu0HSbfAcUqQbcP3IC3JlMCHYhzAdAV6AtMBOqp6tK02ohIFDAKaAtUA3qKSLVkq7XFjUZQGegPjA6g7SPAYlWtjCt6j3htqgE9gOpAG+BNEYkSkdzAq0BzVa0FbARy3vFw4cvcb2d7VrrppI0xKTtxGMZ3g1y53eCa+Qv7nShbCLQ32mLgOlWdo6qfqeohERmbTrMGwA5V3amqZ4BJQKdk63QCPlRnFVBYREqn07YTMM57Pg7onGT5JFU9rao/ATu87Yj3p6CICFAI2BfIfmc7tW6Dap3h8/+4+TeMMX8Wfxom3+6mDeg5EYpU8DtRthHoabSKwMMiMjzJsvTGQSkL/JzkdYy3LJB10mpbSlV/AfAeS6a1LVWNAwYBm3BFphqQ4jj83gRxq0Vk9cGDB9PZvQgkAu1fhgLF3OgCcaf8TmRM+FCF2X9zR/9dRruZcE3QBFpsjgItgVIi8qmIXBJAm5SupiXve5vaOoG0DejzRCQaV2zqAGVwp9GGpbQBVR2rqvVUtV6JEiXS+bgIVaAodB4FB7fA4if9TmNM+Fj2PGyc7O5Pq3GL32mynUCLjahqvKoOBqYBK/jfEUVqYoDySV6X4/zTV6mtk1bb/d6pNrzHA+lsqzaAqv6oqgpMAf6STvbsrdKN0KA/rHoTdi71O40x/ts4FZb+B67pBU0f9DtNthRosRlz9omqfoDrKJDeGCjfApVFpKKI5MFdvJ+dbJ3ZQG+vV1pD4Jh3aiyttrOBPt7zPsCsJMt7iEheEamI63TwDbAXqCYiZw9VWgE/BLjf2deNT0LxKjBzMMQe8TuNMf7ZswpmDYbLm0CHV62Lc4ikN1NnIe/pVK/LcVERKQr8BKRZ/lU1Htfraz7uy32Kqm4WkYEiMtBbbS6wE3cx/21gcFptvTbPAa1EZDuucDzntdmMO2r5HtdN+15VTVDVfcCTwHIR2Yg70rFxwfMUgK5j4Y/9MMd+kzM51G87YVIvuKQ8dP8IcufxO1G2JZrGECYi8pmqtheRnzj/Woqq6hWhDuiXevXq6erVq/2OEXrLX4Alz8At70LNW/1OY0zWiT0C794EJw7C3Yuh2JV+J8oWRGSNqp7XgSzNydNUtb33WDFUwYzPGt/vRoWe8wBc1tBGszU5Q0IcTOkNv/0EvWdZockCgd5n01hECnrP/yoiL4nIZaGNZrJEVG7o+hYkxLvrN4mJficyJrRU4bP73XA0HV+HCo39TpQjBNpBYDRwUkSuwQ1Tsxv4KGSpTNYqegW0GQE/LYNv3vI7jTGh9eWrsO4jaDYUavf0O02OEWixife6DXcCXlXVVwGbpi47qdsbqrSFhcPhgHXWM9nU97Nh0XB3H03zR/1Ok6MEWmx+F5FhwF+BOd7YZTYyXXYiAh1fc1PdTr8H4s/4nciY4Nq7xo2cUa4BdHrTujhnsUCLTXfclAJ3qeqvuKFhXghZKuOPi0q6c9i/bnI3uBmTXRz9GSb0cP/Ge0yA6Hx+J8pxAh31+VdVfUlVv/Be71HVD0MbzfjiqpvdKbUVr8DulX6nMSbzTh2HCd3dIJu9psBF2XQoqjAX6JGNyUlaj4Ail8OM/u4/qjGRavdKGHuDuw552zgoeZXfiXIsKzbmfHkvgi5j4VgM/DfFMUuNCX97voYP2sFvP0KuKMhT0O9EOZoVG5Oyy66DJg/A+o/hh0/9TmNMxn3xEqg3K60mwq4v/M2TwwV6U2d7EVknIr+JyHER+V1E7PxKdnfDI1C6tpuH/ff9fqcxJnDb5qPb55NALuI1F6c0imVn7BSanwI9snkFN8JyMVUtpKoXq2qhdNqYSBcV7QbrPHMCZg9xd14bE+5+3UTc5L58rxX46+lHeCm+G71O/4uBS6OYuW6v3+lyrECLzc/Ad5rWqJ0meypRFVo9DdsXwJr3/U5jTNp+/xUmdOdIQn7uPP0gK7UGbyZ0Yq1WITYugRfmb/U7YY6V5kCcSTwEzBWRZbj7bQBQ1ZdCksqEl/p3w7Z5MP9RqNAMilfyO5Ex5ztzEib2gNij9D39KAcoct4q+47G+hDMQOBHNs8CJ4F8uGFqzv4xOUGuXNBpFETlcd2hE+L9TmTMnyUmun+b+9bDre9y7JKrU1ytTOH8WZvLnBPokU1RVb0ppElMeCtUBjq8AlP7whcvwg0P+53ImP9Z/KTrNdl6BFRty9DWexk2fROxcQnnVskfHcXQ1lV9DJmzBXpks0hErNjkdNW7QK3usOz/IGaN32mMcdZ+CF++AvXugoaDAOhcpywjutakbOH8CFC2cH5GdK1J5zplfY2ak6U5U+e5lUR+BwrirtfE4Wbs1OzcIy3HzNSZUbFHYXRjyJ0XBn5hN8oZf+1cBh93hYrNoNdUNz+T8VVqM3UGOjbaxaqaS1XzW9fnHC5/Yegyxs3dvvBxv9OYnOzQdphyBxSrBN0+sEIT5gL+6YhIEaAyrpMAAKq6PBShTJir2BQa3Qsr34AqbaByK78TmZzmxGEY3811Wuk1BfJd4ncik45ARxC4G1gOzAee9B6fCF0sE/ZaPg4lq8Ose91/fGOySvxpmHw7HN8HPSa6QWNN2Au0g8B9QH1gt6o2B+oAB0OWyoS/3Hnd6AKxR+Cz+2x0AZM1VGH232DPSugyGsrX9zuRCVCgxeaUqp4CEJG8qroFsD6EOd2lNaDFv12X0w0T/U5jcoLlI2HjZGj+bze1s4kYgRabGBEpDMwEForILGBfqEKZCNJoCFzeBOY+BEd2+53GZGebPoHPn4FaPaDZg36nMRkUaG+0Lqp6VFWfAB4D3gU6hzCXiRS5otzpDBGYMRASE9JvY0xG/fwNzBwMl/0FOr7m/r2ZiBLwfDYi0kRE7lTVZcBKwO6OMk7hy+DmF2DPV/DV636nMdnNkV0wsacbxaL7x+56oYk4gfZGGw48DJydtjEa+DhUoUwEqtUdqnWCJc/ALxv9TmOyi1PHYEJ3SIyD26dCwWJ+JzIXKNAjmy5AR+AEgKruwwbiNEmJQPtXoEAxmN4f4k75nchEuoQ4mNIHDu9wRzTFK/udyGRCoMXmjDeXjQKIiI1RYs5XoCh0HgUHf4AlT/udxkQyVZg7FHZ+Dh1edcPRmIgWaLGZIiJvAYVF5B5gEfB26GKZiFXpRqh/jxtdYOcyv9OYSLXqTTdZX+N/QJ2/+p3GBEGgvdFGAp8A03D31zyuquleCRaRNiKyVUR2iMgjKbwvIvKa9/5GEambXlsRKSoiC0Vku/dYJMl7w7z1t4pI6yTL84jIWBHZJiJbRMQ66IdSq6egWGWYOcgN3GlMRmz1Juq7ugO0HO53GhMkAfdGU9WFqjoUeA53ZJMmEYkCRgFtgWpATxGplmy1trjx1ioD/YHRAbR9BFisqpWBxd5rvPd7ANWBNsCb3nYAHgUOqGoVb3v2K3co5SngRhf4Y787FWJMoH7ZAJ/cBWVqQ5exbuI+ky2k+ZMUkYYislREpotIHRH5DvgO2C8ibdLZdgNgh6ruVNUzwCSgU7J1OgEfqrMKd5qudDptOwHjvOfj+N/9Pp2ASap6WlV/AnZ42wHoB4wAUNVEVT2UTnaTWWXrwvUPw6Yp8N00v9OYSHB8H0zoAfmLQM9J7pcWk22k92vDG8B/gInAEuBuVb0UaIb35Z2GssDPSV7HcP69Oamtk1bbUqr6C4D3WDKtbXkjHwA8LSJrRWSqiJRKKbCI9BeR1SKy+uBBG/ot05o8AOXqw2f3uy8SY1Jz5oTr4nz6OPSaDBdf6nciE2TpFZvcqrpAVacCv3pHH3hjo6UnpVt8k4/WmNo6gbQN9PNyA+WAL1W1Lu6G1JEpbUBVx6pqPVWtV6JEiXQ+zqQrKjd0ect1YZ05yM0Tb0xyiQkw7R7Y/x3c+p4bc89kO+kVm6TfDrHJ3kvvyz8GKJ/kdTnOH08ttXXSarvfO9WG93ggnW0dBk4CM7zlU4G6mKxR7Epo/R/YuRS+Get3GhOOFg2HrXOgzXNQpXX665uIlF6xuUZEjnvTQtfynp99XTOdtt8ClUWkoojkwV28n51sndlAb69XWkPgmHdqLK22s4E+3vM+wKwky3uISF4RqYjrdPCNd3/Qp8AN3notge/TyW6C6dq+bpK1RcPhQCAHxSbHWP2+G+KoQX+4boDfaUwIpTlTp6pGpfV+Om3jRWQIbqK1KOA9Vd0sIgO998cAc4GbcRfzTwJ3ptXW2/RzuPt+7gL2AN28NptFZAqukMQD96rq2VEhHwY+EpFXcPPw3Hmh+2UugAh0fB3ebATT74G7F0PuPH6nMn778XOY80+o1Apap3cJ2EQ6UZv0KkX16tXT1atX+x0je9kyByb1gqb/dDN9mpzr4FZ4pxVcUhb6zYd8hfxOZIJERNaoar3ky60Tu8k6V7WDOnfAipdhzyq/0xi/nDgE47u50Zt7TbZCk0NYsTFZq80INyXB9P5w+ne/05isFnfKHd3+sd/dS1P4Mr8TmSyS5jUbY4Iu78WuO/T7bdk1/j5uP/BX9h2NpUzh/AxtXZXOdWyapGxLFWbdCz9/Dd3GQblr/U5kspAd2Zisd1lDtla6mwp7plH9+HIU2Hs0lmHTNzFz3V6/05lQWfZ/8N0n7npd9c5+pzFZzIqN8UX/PTeyKbECL0S/xYNRk6kr24iNS+CF+Vv9jmZCYeMUWDoCat/uRpYwOY4VG+OLPcfiGRvfjkKc5N7cs5iQ51nqyjb2HU1+77CJeHtWudNnlzdxE+xJSoN9mOzOio3xRZnC+Skvh0hEEIG8xHFn1H8pUzi/39FMMP32k+sQcEl56P6R3V+Vg1mxMb4Y2roq63LV4AzRxGsuEhE65F7F5GJvQ+wRv+OZYIg9ChNuA02E26e6mVxNjmW90YwvXK+zW7hvXm4qnVjPzgK1+HulA1TbOgpGN4bOo+GK6/2OaS5UQhxM6e2ObHrPdGPkmRzNRhBIhY0g4JO9a909OIe3Q6MhrudS7rx+pzIZoQqf3gdrx7lfGmr38juRyUI2goCJDGXrwoDlUP9uWPkGvN0C9m9Ov50JHyvfcIWm6T+t0JhzrNiY8JOnALR7EXpNhT8OwNjmsHKUzYcTCX74DBY8BtU6Q/N/+53GhBErNiZ8VbkJBq+ESjfC/H/BR53hmN30Gbb2rXOjepe9FrqMgVz29WL+x/41mPBWsDj0GO+mKIhZDaMbwXfT/U5lkju2Fyb0gALFoedEiLYu7ObPrNiY8CcCdXvDwC+gWGX45E6YPgBOHfM7mQE4/QdM7A5nTrhRnC8q6XciE4as2JjIUexKN/fJDcNg01QY3QR2f+V3qpwtMQGm3e06cXT7AEpV8zuRCVNWbExkicoNNzwCdy1wz9+/GRY9AfFn/E6WMy14DLbNg7bPQ+Ub/U5jwpgVGxOZytWDAV+402srXoZ3WsKBLX6nylm+fRdWjYLrBkGDe/xOY8KcFRsTufJeBB1fgx4T4fheGHs9fP2Wu6nQhNaOxTB3KFRuDa2f9TuNiQBWbEzku+pmGLQSKjaDeQ/Bx7fA77/6nSr7OvADTO0LJa+GW9+FXFF+JzIRwIqNyR4uLgW9pkC7l1yngTcbwfez/U6V/fxxAMbf5ro295rsZl41JgBWbEz2IQL173JdpAtfBlPugJn3wunf/U6WPcTFuukCThyEnpPgknJ+JzIRxIqNyX6KV4a7F0HTB2HDBBjTBPZ87XeqyJaYCDMHQ8y30HWsG8POmAywYmOyp6hoaPkY3DnPdRh4vw0secYNfW8ybukI2DwdbnwSqnX0O42JQFZsTPZ2WUMYuAKu6QXLX4B3W8GhHX6niizrJ8Ly56HOHdD4Pr/TmAhlxcZkf/kKQedRcNuHcGQXvNXU3SNiXaTTt/srmP0319Ov3UvuupgxF8CKjck5qnVyXaQvawhzHoAJ3V3vKpOywz/CpNuhSAVXqHPn8TuRiWBWbEzOUqg03D7NDa/y0zLXRXrLXL9ThZ/YIzDhNve812TIX8TfPCbiWbExOU+uXHDdAOi/zBWfST1h9t/d6MXGjTM3+Q44usdN71DsSr8TmWzAio3JuUpeBXcvgcb/gLUfums5Mav9TuUvVZhzP+z6Ajq+AZf/xe9EJpsIabERkTYislVEdojIIym8LyLymvf+RhGpm15bESkqIgtFZLv3WCTJe8O89beKSOsUPm+2iHwXin01ESp3Hmj1JPT9zHWLfvcmWPp/kBDvdzJ/fPkqrPsYmj0E13T3O43JRkJWbEQkChgFtAWqAT1FJPlkF22Byt6f/sDoANo+AixW1crAYu813vs9gOpAG+BNbztn83QF7DyJSVmFJjDoS6h5Kyz9j7sv5/CPfqfKWt/PhkXDocYt0Pxffqcx2Uwoj2waADtUdaeqngEmAZ2SrdMJ+FCdVUBhESmdTttOwDjv+Tigc5Llk1T1tKr+BOzwtoOIXAQ8ADwTgv002UW+S9zd8be+B4e2wZimsGZczugivXcNTO8P5RpApzeti7MJulAWm7LAz0lex3jLAlknrbalVPUXAO/x7By0abV5GngROJlWYBHpLyKrRWT1wYMH01rVZGc1bnFdpMtdC5/+3XX/PXHI71Shc/RnmNgTLioBPSZAdD6/E5lsKJTFJqVfjZL/ipjaOoG0DejzRKQ2UElVZ6TTHlUdq6r1VLVeiRIl0lvdZGeXlIU7ZsFNz8KOha6L9PaFfqcKvtO/w8QebpDNXlNdwTEmBEJZbGKA8klelwP2BbhOWm33e6fa8B7P3pWXWptGwLUisgtYAVQRkaUXtEcmZ8mVC/4yBO75HAqWgPG3wpx/wpk0D5AjR0I8fNLPzU/T7QPXO8+YEAllsfkWqCwiFUUkD+7iffIJRmYDvb1eaQ2BY96psbTazgb6eM/7ALOSLO8hInlFpCKu08E3qjpaVcuoagWgCbBNVW8IxQ6bbOrSGnDPEmg0BL59B95qBvvW+Z0q8xY8CtsXQLuRUKml32lMNheyYqOq8cAQYD7wAzBFVTeLyEARGeitNhfYibuY/zYwOK22XpvngFYish1o5b3Ge38K8D3wX+BeVU0I1f6ZHCY6n5v+uPcsOHMC3rkRlo+ExAj9J/bN2/D1GFdA6/XzO43JAURzQk+bC1CvXj1dvTqH3+BnUnbyNze22uYZUL4hdH3LjR8WKbYvggndoEob6P6xTetsgkpE1qhqveTLbQQBYzKqQFG49X3oMhYOfA+jm8D6CZHRRXr/ZpjaF0pVh65vW6ExWcaKjTEXQsTdYT/oSyhdC2YOgql93FFPuPp9vxvpOu9F0HOyezQmi1ixMSYzCl8GfT51M1humeu6SO9Y7Heq88XFugFHTx6GnpNc125jspAVG2MyK1cUNPkH3LPYjULwcVeY97D7gg8HiYkwYyDsXQu3vANlavudyORAVmyMCZbS18CAZdBggOvpNfYG+GWj36ng82fg+5lw09NwVTu/05gcyoqNMcEUnR9ufh7+Og1ij8LbLWDFK/51kV43Hr54Ea7t67o5G+MTKzbGhEKlG2HwSqjaxo2kPK6jG4MsK+1aAZ/eB1fcADePtME1ja+s2BgTKgWKwm0fuVGUf1kPoxvDxqlZ89mHdrgBRIteAd3GQVR01nyuMamwYmNMKIlAndth4Ao39tj0u914ZLFHQveZJ3+DCbe5jgu9JkP+wqH7LGMCZMXGmKxQtCL0nQst/g3fz3JHOTuXBf9z4s/A5L/CsRjoMdF9rjFhwIqNMVklKjc0Gwp3LXQdCT7sCPMfhfjTwdm+qrtGs/tL6PwmXHZdcLZrTBBYsTEmq5WtCwOWQ727YOUbMLa5G0Yms1a8BBsmwA3D3PTWxoQRKzbG+CFPQWj/EvSaAicOuIKzcpS7AfNCbJ4Bi5+Cmt3g+oeDm9WYILBiY4yfqrR2U1BXagnz/wUfdYZjezO2jZjVboSA8g2h4xvWxdmEJSs2xvjtohLQYwJ0eBVivoXRjeC76YG1PbrHTet88aXQY7ybd8eYMGTFxphwIOLu8h+4AopVgk/uhOn94dSx1NucOu5GcY4/A72mQsHiWRbXmIyyYmNMOCl2JfSbD9c/Aps+cV2kd315/noJ8a4gHdoG3T+EElWyPqsxGZDb7wDGmGSioqH5MDfkzfR74IN20OQfzCrSh+cX/sS+oycZWfAjbklY5E69XXGD34mNSZcVG2PCVfn67rTa/GGw4mUq6wzqxrXjyeivuDFhHe8mdqBYrlZ09junMQGw02jGhLO8F0HH13k4+hHKcoDXokfRMtc6ElSYE1eXF+Zv9TuhMQGxYmNMBJjyey0+jr8RxfUlUISGubaw72iYTNBmTDqs2BgTAcoUzs/ixLqcJg/xmos4crMq8WrKFM7vdzRjAmLXbIyJAENbV2XY9DPcfuZfNMz1A6sSr+aH3FczonVVv6MZExArNsZEgM51ygLwwvw8jD5ahTKF8zOiddVzy40Jd1ZsjIkQneuUteJiIpZdszHGGBNyVmyMMcaEnBUbY4wxIWfFxhhjTMhZsTHGGBNyVmyMMcaEnKiq3xnCkogcBHan8FZx4FAWxwm17LZPtj/hzfYnvGV2fy5X1RLJF1qxySARWa2q9fzOEUzZbZ9sf8Kb7U94C9X+2Gk0Y4wxIWfFxhhjTMhZscm4sX4HCIHstk+2P+HN9ie8hWR/7JqNMcaYkLMjG2OMMSFnxcYYY0zIWbG5QCLyNxHZKiKbReR5v/Nkhog8ISJ7RWS99+dmvzMFg4g8KCIqIsX9zpJZIvK0iGz0fj4LRKSM35kyQ0ReEJEt3j7NEJHCfmfKDBHp5n0XJIpIxHaDFpE23vfaDhF5JJjbtmJzAUSkOdAJqKWq1YGRPkcKhpdVtbb3Z67fYTJLRMoDrYA9fmcJkhdUtZaq1gY+Ax73OU9mLQRqqGotYBswzOc8mfUd0BVY7neQCyUiUcAooC1QDegpItWCtX0rNhdmEPCcqp4GUNUDPucx53sZeAjIFj1gVPV4kpcFifD9UtUFqhrvvVwFlPMzT2ap6g+qutXvHJnUANihqjtV9QwwCfdLdVBYsbkwVYCmIvK1iCwTkfp+BwqCId4pjfdEpIjfYTJDRDoCe1V1g99ZgklEnhWRn4Hbifwjm6T6AfP8DmEoC/yc5HWMtywobFroVIjIIuDSFN56FPf3VgRoCNQHpojIFRrG/cjT2Z/RwNO435afBl7EfQGErXT251/ATVmbKPPS2idVnaWqjwKPisgwYAgwPEsDZlB6++Ot8ygQD4zPymwXIpD9iXCSwrKgfadZsUmFqt6Y2nsiMgiY7hWXb0QkETd43cGsypdRae1PUiLyNu6aQFhLbX9EpCZQEdggIuBOz6wVkQaq+msWRsywQH9GwARgDmFebNLbHxHpA7QHWobzL2pnZeDnE6ligPJJXpcD9gVr43Ya7cLMBFoAiEgVIA8RPOqriJRO8rIL7mJnRFLVTapaUlUrqGoF3H+guuFeaNIjIpWTvOwIbPErSzCISBvgYaCjqp70O48B4FugsohUFJE8QA9gdrA2bkc2F+Y94D0R+Q44A/SJhN/M0vC8iNTGHTLvAgb4msak5DkRqQok4qa+GOhznsx6A8gLLPSOQFepasTuk4h0AV4HSgBzRGS9qrb2OVaGqGq8iAwB5gNRwHuqujlY27fhaowxxoScnUYzxhgTclZsjDHGhJwVG2OMMSFnxcYYY0zIWbExxhgTclZsjPGBiCR4IzhvEJG1IvKXVNbL7w2JFCUiN4hIijfceqP1fuONpLxeRCaLyGXeeyNFpEUo98eY9Nh9Nsb4I9YbwRkRaQ2MAK5PYb1+uNEqErz7Uc4jIjVw93h0VNUfvGUdgQq4Ua9fB94GlgR3F4wJnB3ZGOO/QsCRVN67HThv3C0RqS8i60TkCtyd+P85W2gAVHW2qi73nu8GiolISuN6GZMl7MjGGH/kF5H1QD6gNN7wR0l5Q4Zcoaq7ki3/C+5opZOq7hGRQOZUWgs0BqZlProxGWdHNsb4I9abqO4qoA3woZx/nqw4cDTZsquBsUAHVT1vYjgRKeZds9kmIg8meesAENGze5rIZsXGGJ+p6kpcYSmR7K1Y3JFPUr8Ap4A6SZZtBup62zrsXQsaC1yUZJ183vaM8YUVG2N8JiJX4QY+PJx0uaoeAaJEJGnBOQq0A/4jIjd4y57HzXNzdZL1CiT7mCpE8GjeJvLZNRtj/HH2mg24Sav6qGpCCustAJoAi84uUNX9ItIBmCci/VT1axG5D3cq7mJc0dqDN9+NiEQDlYDVIdsbY9Jhoz4bE8ZEpA7wgKrekYltdMHN6fNY8JIZkzF2Gs2YMKaq64DPRSQqE5vJjZvq2xjf2JGNMcaYkLMjG2OMMSFnxcYYY0zIWbExxhgTclZsjDHGhJwVG2OMMSH3/3Xz5/Fn7lkXAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from pyemittance.emittance_calc import EmitCalc\n",
+    "# this is the main class for the emittance measurement \n",
+    "\n",
+    "# pass this info to the Emittance Calc class to start a measurement\n",
+    "ef = EmitCalc({'x': quad_field_kG, 'y': quad_field_kG},\n",
+    "              {'x': x_sizes, 'y': y_sizes},\n",
+    "              {'x': x_sizes_err, 'y': y_sizes_err}\n",
+    "              )\n",
+    "ef.plot = True\n",
+    "\n",
+    "# get normalized transverse emittance, the out_dict is the results returned in a dictionary\n",
+    "out_dict = ef.get_emit()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8879854d-fc2a-4b85-842e-e32256af7ff0",
+   "metadata": {},
+   "source": [
+    "### Returned dictionary output of pyemittance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "id": "a5a73a82-c28c-4537-ad93-ca29637c728b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'nemitx': 2.1583252433314983e-07,\n",
+       " 'nemity': 2.1089024848400458e-07,\n",
+       " 'nemitx_err': 3.446757299528848e-09,\n",
+       " 'nemity_err': 4.0158327760268515e-09,\n",
+       " 'bmagx': 1.16556007968336,\n",
+       " 'bmagy': 1.3857156359913343,\n",
+       " 'bmagx_err': 0.01861351863024351,\n",
+       " 'bmagy_err': 0.02638719575357349,\n",
+       " 'opt_q_x': -4.376886589760936,\n",
+       " 'opt_q_y': -2.9179243931739567,\n",
+       " 'quadvalsx': array([-5.83584879, -4.37688659, -2.91792439, -1.4589622 ,  0.        ]),\n",
+       " 'beamsizesx': [7.71939923159646e-05,\n",
+       "  4.03960159655086e-05,\n",
+       "  3.81054984436276e-05,\n",
+       "  7.26370995851494e-05,\n",
+       "  0.000113857730743476],\n",
+       " 'quadvalsy': array([-5.83584879, -4.37688659, -2.91792439, -1.4589622 ,  0.        ]),\n",
+       " 'beamsizesy': [0.000107353736522507,\n",
+       "  5.4595853806668e-05,\n",
+       "  2.65273299632248e-05,\n",
+       "  7.01234748102133e-05,\n",
+       "  0.000125893639569768]}"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "out_dict "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "id": "e5ac39dd-77e7-4e29-94ef-3ea9509d5039",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Emittance from pyemittance: 0.21 mm mrad\n",
+      "Emittance from Bmad: 0.23 mm mrad\n"
+     ]
+    }
+   ],
+   "source": [
+    "# get geom mean of normalized emittances\n",
+    "# running this function adds the transverse normalized emittance to the output dictionary too\n",
+    "ef.get_gmean_emit()\n",
+    "\n",
+    "print(f\"Emittance from pyemittance: {out_dict['nemit']/1e-6:.2f} mm mrad\")\n",
+    "print(f\"Emittance from Bmad: {min(np.sqrt( np.array(norm_emit_x)*np.array(norm_emit_y) ))/1e-6:.2f} mm mrad\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "be800b1a-0289-48a8-bd17-627a23cc1aaf",
+   "metadata": {},
+   "source": [
+    "# ========================================================================="
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f779d236-6dc0-491f-93c2-5f3a5d10dba3",
+   "metadata": {},
+   "source": [
+    "# How to get this machine ready\n",
+    "## Define I/O with machine \n",
+    "To run this similarily to the machine, we define a function that communicates with the \"machine\" (which in this case was Bmad). The function needs to specify the new value for the quadrupole (or other beamline values, here called \"config\"), and return the beamsizes and the corresponding errors. Pyemittance is set up to be used with meters and kGauss units, so the Bmad units needed to be converted accordingly. \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "id": "4263ece9-c1b3-4a58-96b4-eafcbc1e4dbf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# function to transform quad values from fields in kGauss to K1 in 1/m2\n",
+    "from pyemittance.optics import get_gradient, get_k1 \n",
+    "\n",
+    "def get_bs_bmad(config, quad_val):\n",
+    "    '''PyEmittance requires a function to get the beamsize from a model\n",
+    "    to take two params and return the beamsizes and errors\n",
+    "    config: values of SOL, CQ, SQ in CU injector \n",
+    "    quad_val: quadrupole value for measurement IN KG!\n",
+    "    '''\n",
+    "    config = [] # we are not changing anything in the injector here\n",
+    "    \n",
+    "    # convert to sim units\n",
+    "    quad_k1 = get_k1(get_gradient(quad_val))\n",
+    "    \n",
+    "    try:\n",
+    "        tao.cmd(f'set ele QE04 K1={quad_k1}')\n",
+    "    except RuntimeError:\n",
+    "        pass\n",
+    "\n",
+    "    # bunch statistical data\n",
+    "    stats = tao.bunch_params('OTR2')\n",
+    "    x_size = stats[\"sigma_x\"]\n",
+    "    y_size = stats[\"sigma_y\"]\n",
+    "\n",
+    "    # return xrms, yrms, xrms_err, yrms_err\n",
+    "    return x_size, y_size, 0, 0\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32e99d66-781a-4e86-84a5-ff704e8f9183",
+   "metadata": {},
+   "source": [
+    "## Now we put this in an all-in-one function that can run by defining how the beamsize is measured \n",
+    "This was done for the machine and the sim in pyemittance.emit_eval_example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "id": "386c6e74-f4f2-41a3-aaf3-109286907203",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pyemittance.emit_eval_example import eval_emit_surrogate # simulation evaluation function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "id": "ccb85cac-6d6e-441b-97bc-a9ee11085bb8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[0;31mSignature:\u001b[0m\n",
+       "\u001b[0meval_emit_surrogate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mget_bs_model\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mconfig\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mquad_init\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0madapt_ranges\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mnum_points\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mcheck_sym\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0minfl_check\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0madd_pnts\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mshow_plots\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0madd_noise\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0msave_runs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mcalc_bmag\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+       "\u001b[0;31mDocstring:\u001b[0m <no docstring>\n",
+       "\u001b[0;31mFile:\u001b[0m      ~/bmad_quad_scan/pyemittance/emit_eval_example.py\n",
+       "\u001b[0;31mType:\u001b[0m      function\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "eval_emit_surrogate?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "id": "5dacfaa3-96b7-42a7-b623-5fc6de750f5c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# define values to scan on the \"machine\"\n",
+    "init_vals = [-5, -4, -3, -2, -1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "id": "9c29ff51-e67f-44a3-ace1-037bc1a4ca0a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "({'nemitx': 2.1404232640490705e-07,\n",
+       "  'nemity': 2.1264463508964542e-07,\n",
+       "  'nemitx_err': 2.9306847042284364e-09,\n",
+       "  'nemity_err': 3.183763436747894e-09,\n",
+       "  'bmagx': None,\n",
+       "  'bmagy': None,\n",
+       "  'bmagx_err': None,\n",
+       "  'bmagy_err': None,\n",
+       "  'opt_q_x': None,\n",
+       "  'opt_q_y': None,\n",
+       "  'quadvalsx': [-5, -4, -3, -2, -1],\n",
+       "  'beamsizesx': [5.44432076668192e-05,\n",
+       "   3.45540507578362e-05,\n",
+       "   3.68045956223544e-05,\n",
+       "   5.83085101390947e-05,\n",
+       "   8.5349388282595e-05],\n",
+       "  'quadvalsy': [-5, -4, -3, -2, -1],\n",
+       "  'beamsizesy': [7.66548958740404e-05,\n",
+       "   4.22282254989092e-05,\n",
+       "   2.57216840224761e-05,\n",
+       "   5.08254091968863e-05,\n",
+       "   8.72989253767821e-05],\n",
+       "  'nemit': 2.1334233614571262e-07,\n",
+       "  'nemit_err': 4.328487292709863e-09},\n",
+       " 5)"
+      ]
+     },
+     "execution_count": 99,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eval_emit_surrogate(\n",
+    "    get_bs_model=get_bs_bmad,\n",
+    "    config=None,\n",
+    "    quad_init=init_vals,\n",
+    "    adapt_ranges=False,\n",
+    "    check_sym=False,\n",
+    "    infl_check=False,\n",
+    "    add_pnts=False,\n",
+    "    show_plots=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "754aec2d-7779-4cb5-9036-e7140c47ee24",
+   "metadata": {},
+   "source": [
+    "## Making the equivalent functions for the machine with PV input/output"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac2407ab-a733-4abb-a28b-a3212e347ebe",
+   "metadata": {},
+   "source": [
+    "What needs to be defined is a function similar to **get_bs_bmad**.\n",
+    "\n",
+    "This part is all done in the **beam_io.py** file.\n",
+    "The function in this case is in the class **MachineIO** that handles all I/O with the machine (see below example from beam_io.py).\n",
+    "\n",
+    "In the __init__ function, all PVs are imported from the JSON files in the *config* folder. Then the **get_beamsizes_machine** is a simple function that is similar to **get_bs_bmad**: takes beamline and quadrupole value and returns the beamsizes and errors. Inside the function, setting the PVs is simple using the pyepics package, and the beamsizes are measured depending on what is being used.\n",
+    "\n",
+    "- for OTR screens, the otrs_io.py is used to either fit the corresponding beam image and return the sizes, or it can pull the Matlab generated beamsizes from PVs (the option is called ProfMon since it's the profile monitor GUI in the control room that measures these and writes them to PVs)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "id": "0600667e-6a88-4cb7-bb70-60c7524962b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MachineIO():\n",
+    "    \"\"\"Class for handling all machine I/O\"\"\"\n",
+    "    def __init__(self, name='LCLS', meas_type='OTRS'):\n",
+    "        # machine name: only LCLS or FACET are currently supported\n",
+    "        self.name = name\n",
+    "        # specify OTRS or WIRE scans\n",
+    "        self.meas_type = meas_type\n",
+    "        self.online = False\n",
+    "        self.use_profmon = False\n",
+    "        self.settle_time = 3 # sleep time in seconds\n",
+    "\n",
+    "        # load info about PVs used in measurements (e.g. quad scan PV, image PV)\n",
+    "        self.dir, self.filename = path.split(__file__)\n",
+    "        self.CONFIG_PATH = path.join(self.dir, \"configs\")\n",
+    "        self.meas_pv_info = json.load(open(self.CONFIG_PATH + '/meas_pv_info.json'))\n",
+    "\n",
+    "        self.meas_read_pv = PV(self.meas_pv_info['meas_device']['pv']['read'])\n",
+    "        #if self.online:\n",
+    "        # load info about settings to optimize\n",
+    "        self.opt_pv_info = json.load(open(self.CONFIG_PATH + '/opt_pv_info.json'))\n",
+    "        self.opt_pvs = self.opt_pv_info['opt_vars']\n",
+    "        self.meas_cntrl_pv = PV(self.meas_pv_info['meas_device']['pv']['cntrl'])\n",
+    "        self.sol_cntrl_pv = PV(self.opt_pvs[0])\n",
+    "        self.cq_cntrl_pv = PV(self.opt_pvs[1])\n",
+    "        self.sq_cntrl_pv = PV(self.opt_pvs[2])\n",
+    "\n",
+    "    def get_beamsizes_machine(self, config, quad_val):\n",
+    "        \"\"\"Fn that pyemittance.observer calls\n",
+    "        Takes quad value as input,\n",
+    "        Returns xrms, yrms, xrms_err, yrms_err\n",
+    "        \"\"\"\n",
+    "        if self.online and quad_val is not None:\n",
+    "            self.setquad(quad_val)\n",
+    "            self.setinjector(config)\n",
+    "            time.sleep(self.settle_time)\n",
+    "            \n",
+    "        else:\n",
+    "            print(\"Not setting online values.\")\n",
+    "\n",
+    "        if self.meas_type == 'OTRS':\n",
+    "            return get_beamsizes_otrs(self.use_profmon)\n",
+    "\n",
+    "        elif self.meas_type == 'WIRE':\n",
+    "            if self.online:\n",
+    "                return get_beamsizes_wire(self.online)\n",
+    "            else:\n",
+    "                print(\"Not running wire scans.\")\n",
+    "\n",
+    "        else:\n",
+    "            raise NotImplementedError('No valid measurement type defined.')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/sim_optimizer.py b/examples/sim_optimizer.py
new file mode 100644
index 0000000..3a4bf7c
--- /dev/null
+++ b/examples/sim_optimizer.py
@@ -0,0 +1,291 @@
+from argparse import Namespace
+import datetime
+import numpy as np
+from bayes_opt import BayesianOptimization, UtilityFunction
+from scipy import optimize
+
+from pyemittance.emit_eval_example import eval_emit_surrogate
+from lcls_functions import Lcls
+
+
+class Opt:
+    def __init__(self, init_scan=np.linspace(-6, 0, 4), bsfn=None):
+        self.varscan = init_scan
+        self.num_points_adapt = 7
+        self.pbounds = ((0.46, 0.485), (-0.01, 0.01), (-0.01, 0.01))
+        self.plot = False
+        self.bsfn = None
+        self.uncertainty_lim = 0.25
+        self.timestamp = None
+        self.noise = False
+        if bsfn is None:
+            bsfn = self.get_default_bsfn()
+        self.bsfn = bsfn
+        self.total_num_points = 0
+        self.seed = 12
+
+    def get_default_bsfn(self):
+        lcls_params = Namespace(
+            config_bounds=[(self.pbounds[0][0], self.pbounds[0][1]),
+                           (self.pbounds[1][0], self.pbounds[1][1]),
+                           (self.pbounds[2][0], self.pbounds[2][1])],
+            quad_bounds=(-6.0, 0.0),
+            beamsizes_bounds=[(0.0, 5e-4), (0.0, 5e-4)],
+        )
+        lcls = Lcls(params=lcls_params)
+        bsfn = lcls.beamsizes_list_fn
+        return bsfn
+
+    def get_beamsizes_model(self, config, val):
+        beamsizes_list = self.bsfn(config, [val], verbose=False)[0]
+        xrms = beamsizes_list[0]
+        yrms = beamsizes_list[1]
+        xrms_err = xrms * 0.03
+        yrms_err = yrms * 0.03
+        return xrms, yrms, xrms_err, yrms_err
+
+    def evaluate(self, varx, vary, varz):
+        # fixed varscan
+        quad_init = self.varscan
+        config = [varx, vary, varz]
+
+        out_dict, self.total_num_points = eval_emit_surrogate(
+            self.get_beamsizes_model,
+            config,
+            quad_init=list(quad_init),
+            adapt_ranges=True,
+            num_points=self.num_points_adapt,
+            check_sym=True,
+            infl_check=True,
+            add_pnts=True,
+            show_plots=self.plot,
+            add_noise=self.noise,
+        )
+
+        return out_dict
+
+    def evaluate_bo(self, varx, vary, varz):
+        out_dict = self.evaluate(varx, vary, varz)
+
+        emit = out_dict['nemit']
+        emit_err = out_dict['nemit_err']
+
+        if np.isnan(emit):
+            print("NaN emit")
+            return np.nan, np.nan
+
+        if emit_err / emit < self.uncertainty_lim:
+            # save total number of points added
+            timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+            f = open(f"bo_noisy_seed_{self.seed}.txt", "a+")
+            f.write(f'{varx},{vary},{varz},{emit},{emit_err},{self.total_num_points},{timestamp}\n')
+            f.close()
+
+        return -emit, -emit_err
+
+    def run_bo_opt_w_reject(self, rnd_state=11, init_pnts=3, n_iter=200):
+        np.random.seed(self.seed)
+
+        # Set domain
+        bounds = {'varx': self.pbounds[0], 'vary': self.pbounds[1], 'varz': self.pbounds[2]}
+
+        # Run BO
+        optimizer = BayesianOptimization(
+            f=None,
+            pbounds=bounds,
+            random_state=rnd_state,
+            verbose=2
+        )
+
+        # utility = UtilityFunction(kind="ucb", kappa=0.1, xi=0.0)
+        utility = UtilityFunction(kind="ucb", kappa=2.5, xi=0.0)
+
+        target_list = []
+
+        # init random points
+        x = []
+        emit_list = []
+        emit_err_list = []
+
+        emit_res = (np.nan, np.nan)
+        while len(emit_list) < init_pnts:
+            x_i = [np.random.uniform(self.pbounds[0][0], self.pbounds[0][1]),
+                   np.random.uniform(self.pbounds[1][0], self.pbounds[1][1]),
+                   np.random.uniform(self.pbounds[2][0], self.pbounds[2][1])]
+            emit_res = self.evaluate_bo(x_i[0], x_i[1], x_i[2])
+
+            if not np.isnan(emit_res[0]) and not np.isnan(emit_res[1]):  # and abs(emit_res[0]) > 1.0:
+                x.append(x_i)
+                emit_list.append(emit_res[0])
+                emit_err_list.append(emit_res[1])
+
+        # get init points
+        for i in range(len(x)):
+            # target, error = np.nan, np.nan
+            #             while np.isnan(target) or np.isnan(error) or error/target > self.uncertainty_lim:
+            next_point = {'varx': x[i][0],
+                          'vary': x[i][1],
+                          'varz': x[i][2]
+                          }
+            #                 # evaluate next point
+            target = emit_list[i]
+
+            optimizer.register(params=next_point, target=target)
+            if target_list and target > np.max(target_list):
+                color = '\033[95m', '\033[0m'
+            else:
+                color = '\u001b[30m', '\033[0m'
+
+            print(
+                f"{color[0]}iter {i} | target {-1 * target / 1e-6:.3f} | config {next_point['varx']:.6f}"
+                f" {next_point['vary']:.6f} {next_point['varz']:.6f}{color[1]}")
+            target_list.append(target)
+
+        # BO iters
+        for i in range(n_iter):
+            target, error = np.nan, np.nan
+            while np.isnan(target) or np.isnan(error) or error / target > self.uncertainty_lim:
+                next_point = optimizer.suggest(utility)
+                target, error = self.evaluate_bo(**next_point)
+
+            optimizer.register(params=next_point, target=target)
+            if target_list and target > np.max(target_list):
+                color = '\033[95m', '\033[0m'
+            else:
+                color = '\u001b[30m', '\033[0m'
+
+            print(
+                f"{color[0]}iter {i} | target {-1 * target / 1e-6:.3f} | config {next_point['varx']:.6f} "
+                f"{next_point['vary']:.6f} {next_point['varz']:.6f}{color[1]}")
+            emit_list.append(target)
+            emit_err_list.append(error)
+            target_list.append(target)
+
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+
+        np.save(f'bo_opt_res_emit_list_{rnd_state}_{init_pnts}_{n_iter}_{timestamp}.npy',
+                emit_list, allow_pickle=True)
+        np.save(f'bo_opt_res_emit_err_list_{rnd_state}_{init_pnts}_{n_iter}_{timestamp}.npy',
+                emit_err_list, allow_pickle=True)
+        np.save(f'bo_opt_res_{rnd_state}_{init_pnts}_{n_iter}_{timestamp}.npy',
+                optimizer.res, allow_pickle=True)
+
+        return optimizer
+
+    def eval_simplex(self, x):
+        out_dict = self.evaluate(x[0], x[1], x[2])
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+
+        emit = out_dict['nemit']
+        err = out_dict['nemit_err']
+
+        if np.isnan(emit) or (err / emit > self.uncertainty_lim):
+            print("NaN emit")
+            f = open(f"simplex_noisy_seed_{self.seed}.txt", "a+")
+            f.write(f'{x[0]},{x[1]},{x[2]},{np.nan},{np.nan},{self.total_num_points},{timestamp}\n')
+            f.close()
+            return 100
+
+        f = open(f"simplex_noisy_seed_{self.seed}.txt", "a+")
+        f.write(f'{x[0]},{x[1]},{x[2]},{emit},{err},{self.total_num_points},{timestamp}\n')
+        f.close()
+
+        return emit
+
+    def run_simplex_opt(self, max_iter):
+
+        np.random.seed(self.seed)
+
+        initial_guess = np.array(
+            [np.random.uniform(self.pbounds[0][0], self.pbounds[0][1]),
+             np.random.uniform(self.pbounds[1][0], self.pbounds[1][1]),
+             np.random.uniform(self.pbounds[2][0], self.pbounds[2][1])
+             ])
+
+        # initial_guess1 = self.pbounds[0][0]+ np.random.rand(1) * (self.pbounds[0][1] - self.pbounds[0][0])
+        # initial_guess2 = self.pbounds[1][0]+ np.random.rand(1) * (self.pbounds[1][1] - self.pbounds[1][0])
+        # initial_guess3 = self.pbounds[2][0]+ np.random.rand(1) * (self.pbounds[2][1] - self.pbounds[2][0])
+
+        # initial_guess = np.array([initial_guess1, initial_guess2, initial_guess3])
+
+        min = optimize.minimize(self.eval_simplex, initial_guess,
+                                method='Nelder-Mead', options={'maxiter': max_iter,
+                                                               'return_all': True,
+                                                               'adaptive': True,
+                                                               'fatol': 0.1 * 0.75,
+                                                               'xatol': 0.00001
+                                                               },
+                                )
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S")
+        np.save(f'simplex_allvecs_{timestamp}.npy', min["allvecs"], allow_pickle=True)
+
+        f = open(f"simplex_allres_{timestamp}.txt", "a+")
+        f.write(min)
+        f.close()
+
+        return min
+
+    def run_bo_opt(self, rnd_state=11, init_pnts=3, n_iter=200):
+        # Set domain
+        bounds = {'varx': self.pbounds[0], 'vary': self.pbounds[1], 'varz': self.pbounds[2]}
+
+        # Run BO
+        optimizer = BayesianOptimization(
+            f=self.evaluate,
+            pbounds=bounds,
+            random_state=rnd_state,
+        )
+
+        #        optimizer.maximize(init_points=init_pnts, n_iter=n_iter)
+        optimizer.maximize(init_points=init_pnts,
+                           n_iter=n_iter,
+                           kappa=0.01
+                           # kappa_decay = 0.8,
+                           # kappa_decay_delay = 25
+                           )
+
+        return optimizer
+
+    def run_simplex_opt_norm(self, max_iter):
+        np.random.seed(self.seed)
+
+        # below code based on Badger implementation of simplex for the ACR
+
+        # vars init values
+        # x0 = [0.46875, (self.pbounds[1][0] + self.pbounds[1][1]) / 2, (self.pbounds[2][0] + self.pbounds[2][1]) / 2]
+        # ref point from sim
+        x0 = [0.4779693455075814, -0.001499227120199691, -0.0006872989433749197]
+        # lower bounds
+        lb = [self.pbounds[0][0], self.pbounds[1][0], self.pbounds[2][0]]
+        # upper bounds
+        ub = [self.pbounds[0][1], self.pbounds[1][1], self.pbounds[2][1]]
+        # normalization coeff
+        gain = 1.8
+        # tolerance
+        xtol = 1e-9
+
+        # Convert (possible) list to array
+        x0 = np.array(x0)
+        lb = np.array(lb)
+        ub = np.array(ub)
+
+        x0_raw = lb + x0 * (ub - lb)
+        mu = x0_raw - gain * np.sqrt(np.abs(x0_raw))
+        sigma = np.sqrt(np.abs(mu))
+
+        x0_n = (x0_raw - mu) / sigma  # normalized x0
+
+        def _evaluate(x_n):
+            x_n = np.array(x_n)
+            x_raw = mu + sigma * x_n  # denormalization from Ocelot
+            x = (x_raw - lb) / (ub - lb)  # normalization for Badger
+            y = self.eval_simplex(x)
+
+            return y
+
+        res = optimize.fmin(_evaluate, x0_n, maxiter=max_iter, maxfun=max_iter, xtol=xtol, retall=True,
+                            full_output=True)
+
+        print(res)
+
+        return res
\ No newline at end of file
diff --git a/pyemittance/beam_io.py b/pyemittance/beam_io.py
index 251a1fe..2214f82 100644
--- a/pyemittance/beam_io.py
+++ b/pyemittance/beam_io.py
@@ -1,527 +1,92 @@
-# SETUP FILE FOR LCLS CU INJECTOR
 import numpy as np
-import sys, os, errno
+from os import path
 import json
 import time
-import datetime
-import matplotlib.pyplot as plt
-
-from pyemittance.image import Image
-from os.path import exists
-
-from epics import caget, caput, PV
-import epics
-
-this_dir, this_filename = os.path.split(__file__)
-CONFIG_PATH = os.path.join(this_dir, "configs")
-
-online = True
-
-def get_beamsizes_machine(quad_val, use_profmon):
-    """what pyemittance calls"""
-    """Takes quad value as input,
-     returns xrms, yrms, xrms_err, yrms_err"""
-    setquad(quad_val)
-    time.sleep(3)
-    beamsize = get_beamsizes(use_profMon=use_profmon) 
-    xrms = beamsize[0]
-    yrms = beamsize[1]
-    xrms_err = beamsize[2]
-    yrms_err = beamsize[3]
-    return xrms, yrms, xrms_err, yrms_err
-
-def get_twiss0(filepath= CONFIG_PATH+'/beamline_info.json'):
-    """Import Twiss0 from config file"""
-
-    beamline_info = json.load(open(filepath))
-    twiss0 = beamline_info['Twiss0']
-    # emit, beta, alpha
-    twiss0_by_dim = {'x': [twiss0[0], twiss0[2], twiss0[4]],
-                     'y': [twiss0[1], twiss0[3], twiss0[5]]
-                     }
-
-    return twiss0_by_dim
-
-def get_rmat(filepath=CONFIG_PATH+'/beamline_info.json'):
-    """Import r-matrix from config file"""
-
-    beamline_info = json.load(open(filepath))
-    # if only separated by a drift:
-    # rMat will be [1, L, 0, 1]
-    rmat = beamline_info['rMat']
-    # m11, m12, m21, m22
-    rmat_array = np.array([ [rmat[0], rmat[1]],
-                            [rmat[2], rmat[3]]
-                            ])
-
-    return rmat_array
-
-##################################
-# TODO refactor all below #######
-
-# load image processing setting info
-im_proc = json.load(open(CONFIG_PATH+'/img_proc.json'))
-subtract_bg = im_proc['subtract_bg']
-print('sb', subtract_bg)
-bg_image = im_proc['background_im']  # specify path to bg im in json file
-use_roi = im_proc['use_roi']
-roi_xmin = im_proc['roi']['xmin']
-roi_ymin = im_proc['roi']['ymin']
-roi_xmax = im_proc['roi']['xmax']
-roi_ymax = im_proc['roi']['ymax']
-avg_ims = im_proc['avg_ims']
-n_acquire = im_proc['n_to_acquire']
-
-amp_threshold_x = 200  # im_proc['amp_threshold']#1500
-amp_threshold_y = 200
-min_sigma = 1.0  # im_proc['min_sigma']#1.5 # noise
-max_sigma = 1000  # im_proc['max_sigma']#40 # large/diffuse beam
-max_samples = im_proc['max_samples']  # 3 # how many times to sample bad beam
-
-
-def isotime():
-    return datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc).astimezone().replace(
-        microsecond=0).isoformat()
-
-
-isotime()
-
-# load info about PVs used in measurements (e.g. quad scan PV, image PV)
-meas_pv_info = json.load(open(CONFIG_PATH+'/meas_pv_info.json'))
-pv_savelist = json.load(open(CONFIG_PATH+'/save_scalar_pvs.json'))
-
-
-if online:
-    resolution = epics.caget(
-    'PROF:IN10:571:RESOLUTION') * 10 ** -6  # 12.23*1e-6#PV(meas_pv_info['diagnostic']['pv']['resolution'])*1e-6 #12.23*1e-6 # in meters for emittance calc
-    
-    im_pv = PV(meas_pv_info['diagnostic']['pv']['image'])
-    n_col_pv = PV(meas_pv_info['diagnostic']['pv']['ncol'])
-    n_row_pv = PV(meas_pv_info['diagnostic']['pv']['nrow'])
-    x_size_pv = PV(meas_pv_info['diagnostic']['pv']['profmonxsize'])
-    y_size_pv = PV(meas_pv_info['diagnostic']['pv']['profmonysize'])
-
-    meas_cntrl_pv = PV(meas_pv_info['meas_device']['pv']['cntrl'])
-meas_read_pv = PV(meas_pv_info['meas_device']['pv']['read'])
-
-# load info about settings to optimize
-opt_pv_info = json.load(open(CONFIG_PATH+'/opt_pv_info.json'))
-opt_pvs = opt_pv_info['opt_vars']
-
-
-# load info about where to put saving of raw images and summaries; make directories if needed and start headings
-savepaths = json.load(open(CONFIG_PATH+'/savepaths.json'))
-
-if online:
-    sol_cntrl_pv = PV(opt_pvs[0])
-    cq_cntrl_pv = PV(opt_pvs[1])
-    sq_cntrl_pv = PV(opt_pvs[2])
-    
-    def mkdir_p(path):
-        """Set up dirs for results in working dir"""
-        try:
-            os.makedirs(path)
-        except OSError as exc:
-            if exc.errno == errno.EEXIST and os.path.isdir(path):
-                pass
-            else:
-                raise
-
-
-    mkdir_p(savepaths['images'])
-    mkdir_p(savepaths['summaries'])
-    mkdir_p(savepaths['fits'])
-
-
-
-if online:
-
-    file_exists = exists(savepaths['summaries'] + "image_acq_quad_info.csv")
-
-    # print('fe',file_exists)
-
-    if not file_exists:
-        # print('foo1')
-
-        # todo add others as inputs
-        f = open(savepaths['summaries'] + "image_acq_quad_info.csv", "a+")
-        f.write(
-            f"{'timestamp'},{'ncol'},{'nrow'},{'roi_xmin'},{'roi_xmax'},{'roi_ymin'},{'roi_ymax'},{'resolution'},{'bact'},{'x_size'},{'y_size'},{'beamsizes[0]'},{'beamsizes[1]'},{'beamsizes[2]'},{'beamsizes[3]'}\n")
-        f.close()
-
-    file_exists = exists(savepaths['summaries'] + "beamsize_config_info.csv")
-    # print('fe',file_exists)
-    if not file_exists:
-        # print('foo2')
-        # todo add others as inputs
-        f = open(savepaths['summaries'] + "beamsize_config_info.csv", "a+")
-        f.write(
-            f"{'timestamp'},{'varx_cur'},{'vary_cur'},{'varz_cur'},{'bact_cur'},{'xrms'},{'yrms'},{'xrms_err'},{'yrms_err'}\n")
-        f.close()
-
-
-## I/O FUNCTIONS
-def setinjector(set_list):
-    sol_cntrl_pv.put(set_list[0])
-    cq_cntrl_pv.put(set_list[1])
-    sq_cntrl_pv.put(set_list[2])
-
-
-def setquad(value):
-    """Sets Q525 to new scan value"""
-    meas_cntrl_pv.put(value)
-
-
-# def get_beamsize_inj(set_list_pv, set_list_values, quad=meas_input_pv.get(), use_profMon=False):
-def get_beamsize_inj(set_list, quad=meas_read_pv.get(), use_profMon=False):
-    """Get beamsize fn that changes upstream cu injector and returns xrms and yrms in [m]"""
-    setinjector(set_list)
-    setquad(quad)
-    time.sleep(3)
-    beamsize = get_beamsizes(use_profMon=use_profMon)
-    return np.array([beamsize[0], beamsize[1]])
-
-
-def quad_control(val=None, action="get"):
-    if action == "get":
-        return meas_read_pv.get()
-    elif action == "set":
-        setquad(val)
-        return None
-    else:
-        raise ValueError("Invalid quad function")
-
-
-def savesummary(beamsizes, timestamp=(datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")):
-    """Saves summary info for beamsize fits"""
-
-    # todo add others as inputs
-    f = open(savepaths['summaries'] + "image_acq_quad_info.csv", "a+")
-    bact = quad_read_pv.get()
-    x_size = x_size_pv.get()
-    y_size = y_size_pv.get()
-    f.write(
-        f"{timestamp},{ncol},{nrow},{roi_xmin},{roi_xmax},{roi_ymin},{roi_ymax},{resolution},{bact},{x_size},{y_size},{beamsizes[0]},{beamsizes[1]},{beamsizes[2]},{beamsizes[3]}\n")
-    f.close()
-
-
-def saveimage(im, ncol, nrow, timestamp=(datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f"),
-              impath=savepaths['images'], avg_img=True):
-    """Saves images with col,row info and corresp. settings"""
-
-    if avg_img:
-
-        np.save(str(impath) + f'img_avg_{timestamp}.npy', im)
-        np.save(str(impath) + f'ncol_avg_{timestamp}.npy', ncol)
-        np.save(str(impath) + f'nrow_avg_{timestamp}.npy', nrow)
-
-    else:
-
-        np.save(str(impath) + f'img_{timestamp}.npy', im)
-        np.save(str(impath) + f'ncol_{timestamp}.npy', ncol)
-        np.save(str(impath) + f'nrow_{timestamp}.npy', nrow)
-
-
-def get_beam_image(subtract_bg=subtract_bg, post=None):
-    """Get beam image from screen and return beamsize info and processed image"""
-
-    if post:
-        im = post[0]
-        ncol = post[1]
-        nrow = post[2]
-    else:
-        im = im_pv.get()
-        ncol, nrow = n_col_pv.get(), n_row_pv.get()
-
-    beam_image = Image(im, ncol, nrow, bg_image=bg_image)
-    beam_image.reshape_im()
-
-    if subtract_bg:
-        beam_image.subtract_bg()
-
-    if use_roi:
-        beam_image.proc_image = beam_image.proc_image[roi_ymin:roi_ymax, roi_xmin:roi_xmax]
-
-    beam_image.get_im_projection()
-
-    # fit the profile and return the beamsizes
-    beamsizes = beam_image.get_sizes(show_plots=False)
-
-    # save_beam = list(np.array(beamsizes[0:4])*resolution/1e-6)
-
-    timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
-    # savesummary(beamsizes,timestamp)# pass beamsizes in um
-    saveimage(im, ncol, nrow, timestamp, avg_img=False)
-
-    return list(beamsizes) + [beam_image.proc_image]
-
-
-def getbeamsizes_from_img(num_images=n_acquire, avg=avg_ims, subtract_bg=subtract_bg, post=None):
-    """Returns xrms, yrms, xrms_err, yrms_err for multiple sampled images;
-    can optionally average multiple images
-    RETURNS IN RAW UNITS-- NEED TO MULTIPLY BY RESOLUTION FOR M"""
-
-    xrms, yrms, xrms_err, yrms_err, xamp, yamp, im = [0] * num_images, [0] * num_images, [0] * num_images, [
-        0] * num_images, [0] * num_images, [0] * num_images, [0] * num_images
-
-    if post:
-        ncol = post[0][1]
-        nrow = post[0][2]
-    else:
-        ncol, nrow = n_col_pv.get(), n_row_pv.get()
-
-    for i in range(0, num_images):
-
-        repeat = True
-        count = 0
-        # retake bad images 3 times
-        # print(i)
-
-        while repeat:
-            xrms[i], yrms[i], xrms_err[i], yrms_err[i], xamp[i], yamp[i], im[i] = get_beam_image(subtract_bg, post)
-
-            # plt.imshow(im[i])
-            # plt.show()
-
-            count = count + 1
-
-            if xamp[i] > amp_threshold_x and yamp[i] > amp_threshold_y and xrms[i] > min_sigma and yrms[
-                i] > min_sigma and xrms[i] < max_sigma and yrms[i] < max_sigma:
-                # if conditions are met, stop resampling this image
-                repeat = False
-            elif count == 3:
-                # if still bad after 3 tries, return nan
-                print(xamp[i], xrms[i])
-                xrms[i], yrms[i], xrms_err[i], yrms_err[i], xamp[i], yamp[
-                    i] = np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
-                repeat = False
-
-    # average images before taking fits
-    if avg == True:
-
-        im = np.mean(im, axis=0)
-
-        im = Image(im, ncol, nrow, bg_image=bg_image)
-
-        im.reshape_im()
-        if subtract_bg:
-            im.subtract_bg()
-        im.get_im_projection()
-
-        # plt.imshow(im.proc_image)
-
-        mean_xrms, mean_yrms, mean_xrms_err, mean_yrms_err, mean_xamp, mean_yamp = im.get_sizes(show_plots=False)
-
-        if mean_xamp < amp_threshold_x or mean_yamp < amp_threshold_y:
-            return [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
-
-        # save_beam = list(np.array(beamsizes[0:4])*resolution/1e-6)
-
-        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
-        saveimage(im.proc_image, ncol, nrow, timestamp, avg_img=True)  # pass beamsizes in um
-
-        return [mean_xrms, mean_yrms, mean_xrms_err, mean_yrms_err, mean_xamp, mean_yamp, im.proc_image]
-
-
-
-    # average individual rms fits
-    else:
-        idx = ~np.isnan(xrms)
-
-        if True not in idx:
-            return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
-
-        mean_xrms = np.mean(np.array(xrms)[idx])
-        mean_yrms = np.mean(np.array(yrms)[idx])
-        mean_xrms_err = np.std(np.array(xrms)[idx]) / np.sqrt(len(idx))
-        mean_yrms_err = np.std(np.array(yrms)[idx]) / np.sqrt(len(idx))
-        #     mean_xrms_err = np.sqrt(np.mean(np.array(xrms_err)[idx]**2))
-        #     mean_yrms_err = np.sqrt(np.mean(np.array(yrms_err)[idx]**2))
-        mean_xamp = np.mean(np.array(xamp)[idx])
-        mean_yamp = np.mean(np.array(yamp)[idx])
-
-        im = Image(im[0], ncol, nrow, bg_image=bg_image)
-
-        im.reshape_im()
-        im.get_im_projection()
-
-        return [mean_xrms, mean_yrms, mean_xrms_err, mean_yrms_err, mean_xamp, mean_yamp, im.proc_image]
-
-
-def get_beamsizes(use_profMon=False, reject_bad_beam=True, save_summary=True, post=None):
-    """Returns xrms, yrms, xrms_err, yrms_err, with options to reject bad beams and use either profmon or image processing"""
-
-    xrms = np.nan
-    yrms = np.nan
-    xrms_err = np.nan
-    yrms_err = np.nan
-    xamp = np.nan
-    yamp = np.nan
-    beamsizes = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
-    im = None
-
-    # remove hardcoding
-    min_sigma = 0.00000002
-    max_sigma = 0.1
-
-    if reject_bad_beam:
-
-        count = 0
-
-        while xrms <= min_sigma or yrms <= min_sigma or xrms > max_sigma or yrms > max_sigma or np.isnan(
-                np.array(beamsizes[0:6])).any():
-
-            if count > 1:
-                print("Low beam intensity/noisy or beam too small/large.")
-                print("Waiting 1 sec and repeating measurement...")
-                time.sleep(1)
-
-            # make sure stats is checked on profmon gui
-            if use_profMon:
-                beamsizes = []
-                xrms, xrms_err = x_size_pv.get() * 1e-6, 0  # in meters
-                yrms, yrms_err = y_size_pv.get() * 1e-6, 0  # in meters
-                # print('bz',xrms,yrms)
-                # print(x_size_pv)
-                # print(y_size_pv)
-                count = count + 1
-
-            if not use_profMon:
-
-                # if post:
-                #    beamsizes = getbeamsizes_from_img(post = post)
-                #:
-                beamsizes = getbeamsizes_from_img()
-
-                xrms = beamsizes[0]
-                yrms = beamsizes[1]
-                xrms_err = beamsizes[2]
-                yrms_err = beamsizes[3]
-                xamp = beamsizes[4]
-                yamp = beamsizes[5]
-                # im = beamsizes[6]
-
-                # print('raw px',xrms,yrms)
-                # convert to meters
-                xrms = xrms * resolution
-                yrms = yrms * resolution
-                xrms_err = xrms_err * resolution
-                yrms_err = yrms_err * resolution
-
-                #print('bzs', beamsizes)
-
-                # print('res',resolution)
-                #print('after', xrms, min_sigma, yrms, min_sigma, xrms, max_sigma, yrms, max_sigma)
-
-                if count == 1:
-                    # resample beamsize only 3 times
-                    return np.nan, np.nan, np.nan, np.nan
-
-                count = count + 1
-
-
-    else:
-
-        # make sure stats is checked on profmon gui
-        if use_profMon:
-            xrms, xrms_err = x_size_pv.get() * 1e-6, 0  # in meters
-            yrms, yrms_err = y_size_pv.get() * 1e-6, 0  # in meters
-            print("USING PROFMONNNNNNN!!!!")
 
+from epics import PV
+from pyemittance.saving_io import save_config
+
+
+class MachineIO():
+    """Class for handling all machine I/O"""
+    def __init__(self, name='LCLS', meas_type='OTRS'):
+        # machine name: only LCLS or FACET are currently supported
+        self.name = name
+        # specify OTRS or WIRE scans
+        self.meas_type = meas_type
+        self.online = False
+        self.use_profmon = False
+        self.settle_time = 3 # sleep time in seconds
+
+        # load info about PVs used in measurements (e.g. quad scan PV, image PV)
+        self.dir, self.filename = path.split(__file__)
+        if self.meas_type == 'WIRE':
+            add_path = '/LCLS_WS02'
+        elif self.meas_type == 'OTRS':
+            add_path = '/LCLS2_OTR3'
         else:
-            if post:
-                beamsizes = getbeamsizes_from_img(post=post)
-            else:
-                beamsizes = getbeamsizes_from_img()
-            # print(beamsizes)
-
-            xrms = beamsizes[0]
-            yrms = beamsizes[1]
-            xrms_err = beamsizes[2]
-            yrms_err = beamsizes[3]
-            xamp = beamsizes[4]
-            yamp = beamsizes[5]
-            # im = beamsizes[6]
-
-            # convert to meters
-            xrms = xrms * resolution
-            yrms = yrms * resolution
-            xrms_err = xrms_err * resolution
-            yrms_err = yrms_err * resolution
-
-    if save_summary:
-        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
-
-        save_config(xrms, yrms, xrms_err, yrms_err, timestamp=timestamp)  # ,#im)
-        numpy_save(xrms, yrms, xrms_err, yrms_err, timestamp)
-
-    return xrms, yrms, xrms_err, yrms_err
-
-
-def numpy_save(xrms, yrms, xrms_err, yrms_err, timestamp=False, savelist=pv_savelist['scalars'],
-               path=savepaths['raw_saves']):
-    ts = isotime()
-    x = epics.caget_many(savelist)
-    x.append(ts)
-    if timestamp:
-        x.append(timestamp)
-    else:
-        x.append(ts)
-    x.append(xrms)
-    x.append(yrms)
-    x.append(xrms_err)
-    x.append(yrms_err)
-
-    np.save(path + ts + '_x_.npy', np.array(x))
-
-
-# def numpy_save(timestamp=False,savelist = pv_savelist['scalars'],path =savepaths['raw_saves']):
-
-
-#     ts = isotime()
-#     x = epics.caget_many(savelist)
-#     x.append(ts)
-#     if timestamp:
-#         x.append(timestamp)
-#     else:
-#         x.append(ts)
-
-
-#     img=epics.caget('PROF:IN10:571:Image:ArrayData')
-#     nrow = epics.caget('PROF:IN10:571:Image:ArraySize0_RBV')
-#     ncol = epics.caget('PROF:IN10:571:Image:ArraySize1_RBV')
-
-#     res = epics.caget('PROF:IN10:571:RESOLUTION')
-
-#     nrow1 = caget("CAMR:LT10:900:Image:ArraySize0_RBV")
-#     ncol1 = caget("CAMR:LT10:900:Image:ArraySize1_RBV")
-
-#     resolution1 = caget("CAMR:LT10:900:RESOLUTION")
-#     im1 =caget('CAMR:LT10:900:Image:ArrayData')
-
-
-#     np.save(path+ts+'_571_img_.npy',img.reshape((ncol,nrow)))
-#     np.save(path+ts+'_571_res_.npy',np.array(res))
-
-#     np.save(path+ts+'_x_.npy',np.array(x))
-
-#     np.save(path+ts+'_vcc_img_.npy',im1.reshape((ncol1,nrow1)))
-#     np.save(path+ts+'_vcc_res_.npy',np.array(resolution1))
-
-
-def save_config(xrms, yrms, xrms_err, yrms_err, config_path=savepaths['summaries'],
-                timestamp=(datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f"), im=None,
-                impath=savepaths['images']):
-    f = open(savepaths['summaries'] + "beamsize_config_info.csv", "a+")
-
-    # todo make more general, pandas etc
-    varx_cur = caget(opt_pvs[0])
-    vary_cur = caget(opt_pvs[1])
-    varz_cur = caget(opt_pvs[2])
-    bact_cur = meas_read_pv.get()
-    f.write(f"{timestamp},{varx_cur},{vary_cur},{varz_cur},{bact_cur},{xrms},{yrms},{xrms_err},{yrms_err}\n")
-
-    f.close()
+            add_path = ''
+        self.CONFIG_PATH = path.join(self.dir, 'configs' + add_path)
+        self.meas_pv_info = json.load(open(self.CONFIG_PATH + '/meas_pv_info.json'))
+
+        self.meas_read_pv = PV(self.meas_pv_info['meas_device']['pv']['read'])
+        #if self.online:
+        # load info about settings to optimize
+        self.opt_pv_info = json.load(open(self.CONFIG_PATH + '/opt_pv_info.json'))
+        self.opt_pvs = self.opt_pv_info['opt_vars']
+        self.meas_cntrl_pv = PV(self.meas_pv_info['meas_device']['pv']['cntrl'])
+        self.sol_cntrl_pv = PV(self.opt_pvs[0])
+        self.cq_cntrl_pv = PV(self.opt_pvs[1])
+        self.sq_cntrl_pv = PV(self.opt_pvs[2])
+
+    def get_beamsizes_machine(self, config, quad_val):
+        """Fn that pyemittance.observer calls
+        Takes quad value as input,
+        Returns xrms, yrms, xrms_err, yrms_err
+        """
+        if self.online and quad_val is not None:
+            self.setquad(quad_val)
+            self.setinjector(config)
+            time.sleep(self.settle_time)
+        else:
+            print("Running offline.")
+
+        if self.meas_type == 'OTRS' and self.online:
+            from pyemittance.otrs_io import get_beamsizes_otrs
+            return get_beamsizes_otrs(self.use_profmon)
+        elif self.meas_type == 'WIRE' and self.online:
+            from pyemittance.wire_io import get_beamsizes_wire
+            print("Running wire scanner")
+            return get_beamsizes_wire(self.online)
+        elif not self.online:
+            return np.random.uniform(0.5e-4,5e-4), np.random.uniform(1e-4,6e-4), 0, 0
+        else:
+            raise NotImplementedError('No valid measurement type defined.')
+
+    def setinjector(self, set_list):
+        if self.online and set_list is not None:
+            self.sol_cntrl_pv.put(set_list[0])
+            self.cq_cntrl_pv.put(set_list[1])
+            self.sq_cntrl_pv.put(set_list[2])
+        elif not set_list:
+            pass
+        else:
+            print("Not setting injector online values.")
+            pass
 
-    if im:
-        np.save((str(impath) + f'img_config_{timestamp}.npy', im.proc_image))
\ No newline at end of file
+    def setquad(self, value):
+        """Sets Q525 to new scan value"""
+        if self.online:
+            self.meas_cntrl_pv.put(value)
+        else:
+            print("Not setting quad online values.")
+            pass
+
+    def get_beamsize_inj(self, set_list, quad):
+        """Get beamsize fn that changes upstream cu injector
+        Returns xrms and yrms in [m]
+        """            
+        beamsize = self.get_beamsizes_machine(set_list, quad)
+        # save BAX beam size data
+        save_config(beamsize[0], beamsize[1], beamsize[2], beamsize[3], None)
+        return np.array([beamsize[0], beamsize[1]])
diff --git a/pyemittance/bs_fitting_methods.py b/pyemittance/bs_fitting_methods.py
index 83a3d0b..9e0b708 100644
--- a/pyemittance/bs_fitting_methods.py
+++ b/pyemittance/bs_fitting_methods.py
@@ -90,7 +90,7 @@ def find_rms_cut_area(y, para0 = None, show_plots=False, cut_area = 0.05):
 
     return para, para_errors
 
-def plot_fit(x, y, para_x,  savepath='', show_plots=False, save_plots=False):
+def plot_fit(x, y, para_x,  savepath='', show_plots=True, save_plots=False):
     """
     Plot  beamsize fit in x or y direction
     """
diff --git a/pyemittance/configs/FACET_nominal/beamline_info.json b/pyemittance/configs/FACET_nominal/beamline_info.json
index 866e62d..ebef231 100644
--- a/pyemittance/configs/FACET_nominal/beamline_info.json
+++ b/pyemittance/configs/FACET_nominal/beamline_info.json
@@ -1,1 +1,1 @@
-{"m_0": 0.000511, "d": 2.7012, "l": 0.108, "energy": 0.125, "Twiss0": [5.3e-06, 4.9e-06, 1.1106, 1.1106, -0.0979, -0.0979]}
\ No newline at end of file
+{"name": "FACET-II", "m_0": 0.000511, "d": 2.7012, "l": 0.108, "energy": 0.125, "Twiss0": [5.3e-06, 4.9e-06, 1.1106, 1.1106, -0.0979, -0.0979], "rMat": [1, 2.7012, 0, 1] }
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS2_OTR3/beamline_info.json b/pyemittance/configs/LCLS2_OTR3/beamline_info.json
new file mode 100644
index 0000000..207b3a4
--- /dev/null
+++ b/pyemittance/configs/LCLS2_OTR3/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS2", "m_0": 0.000511, "d": 4.17, "l": 0.1244, "energy": 0.08, "Twiss0": [1e-6, 1e-6, 5.01, 5.01, 0.049, 0.049], "rMatx": [-4.4253119 ,5.13116104,-2.00365218,2.09726731],"rMaty": [ 2.96145465,  4.39756326,-1.69886062, -2.18502317]}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS2_OTR3/img_proc.json b/pyemittance/configs/LCLS2_OTR3/img_proc.json
new file mode 100644
index 0000000..f3209d3
--- /dev/null
+++ b/pyemittance/configs/LCLS2_OTR3/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": true, "use_roi": false, "avg_ims": true, "n_to_acquire": 1, "background_im": "/home/physics3/ml_tuning/20220805_LCLS2_inj/example_images/bg_8_6_22.npy", "amp_threshold": 150, "min_sigma": 3, "max_sigma": 700, "max_samples": 1, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS2_OTR3/meas_pv_info.json b/pyemittance/configs/LCLS2_OTR3/meas_pv_info.json
new file mode 100644
index 0000000..97d8b65
--- /dev/null
+++ b/pyemittance/configs/LCLS2_OTR3/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:HTR:330", "image": "OTRS:HTR:330:Image:ArrayData", "ncol": "OTRS:HTR:330:Image:ArraySize1_RBV", "nrow": "OTRS:HTR:330:Image:ArraySize0_RBV", "resolution": "OTRS:HTR:330:RESOLUTION", "profmonxsize": "OTRS:HTR:330:XRMS", "profmonysize": "OTRS:HTR:330:YRMS", "scan": "", "xsize": "", "ysize": ""}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:HTR:120", "cntrl": "QUAD:HTR:120:BCTRL", "read": "QUAD:HTR:120:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": ""}}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS2_OTR3/opt_pv_info.json b/pyemittance/configs/LCLS2_OTR3/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/LCLS2_OTR3/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS2_OTR3/save_scalar_pvs.json b/pyemittance/configs/LCLS2_OTR3/save_scalar_pvs.json
new file mode 100644
index 0000000..0ff2ee1
--- /dev/null
+++ b/pyemittance/configs/LCLS2_OTR3/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:621:XRMS", "OTRS:IN20:621:YRMS", "OTRS:IN20:621:X", "OTRS:IN20:621:Y", "OTRS:IN20:621:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS2_OTR3/savepaths.json b/pyemittance/configs/LCLS2_OTR3/savepaths.json
new file mode 100644
index 0000000..e5e44d2
--- /dev/null
+++ b/pyemittance/configs/LCLS2_OTR3/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/saved_fits/", "images": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/saved_images/", "monitoring": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/monitoring/", "summaries": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/summaries/", "raw_saves": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/raw_saves/", "emit_saves": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/emit_saves/", "mon_saves": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/mon_saves/", "xopt_saves": "/home/physics3/ml_tuning/20220805_LCLS2_inj/data_saving/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR1/beamline_info.json b/pyemittance/configs/LCLS_OTR1/beamline_info.json
index ab7c7b0..fb1c029 100644
--- a/pyemittance/configs/LCLS_OTR1/beamline_info.json
+++ b/pyemittance/configs/LCLS_OTR1/beamline_info.json
@@ -1,1 +1,1 @@
-{"energy": 0.135, "Twiss0": [1e-06, 1e-06, 4.16157667, 4.16157699, 1.66328017, 1.66328028], "rMat": [1.1055070102091, 2.74258378560201, -0.213608624301716, 0.374633943250189] }
\ No newline at end of file
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-06, 1e-06, 4.16157667, 4.16157699, 1.66328017, 1.66328028], "rMat": [1.1055070102091, 2.74258378560201, -0.213608624301716, 0.374633943250189] }
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR1/meas_pv_info.json b/pyemittance/configs/LCLS_OTR1/meas_pv_info.json
index 6f349fb..127f4c5 100644
--- a/pyemittance/configs/LCLS_OTR1/meas_pv_info.json
+++ b/pyemittance/configs/LCLS_OTR1/meas_pv_info.json
@@ -1,1 +1,1 @@
-{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS", "scan": "SIOC:SYS0:ML01:AO020", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR1/savepaths.json b/pyemittance/configs/LCLS_OTR1/savepaths.json
index 119b551..5151a1f 100644
--- a/pyemittance/configs/LCLS_OTR1/savepaths.json
+++ b/pyemittance/configs/LCLS_OTR1/savepaths.json
@@ -1,1 +1,1 @@
-{"fits": "/home/physics/smiskov/20220203/saved_fits/", "images": "/home/physics/smiskov/20220203/saved_images/", "monitoring": "/home/physics/smiskov/20220203/monitoring/", "summaries": "/home/physics/smiskov/20220203/summaries/", "raw_saves": "/home/physics/smiskov/20220203/raw_saves/", "emit_saves": "/home/physics/smiskov/20220203/emit_saves/", "mon_saves": "/home/physics/smiskov/20220203/mon_saves/", "xopt_saves": "/home/physics/smiskov/20220203/xopt_saves/"}
\ No newline at end of file
+{"fits": "/home/physics/smiskov/20220329/saved_fits/", "images": "/home/physics/smiskov/20220329/saved_images/", "monitoring": "/home/physics/smiskov/20220329/monitoring/", "summaries": "/home/physics/smiskov/20220329/summaries/", "raw_saves": "/home/physics/smiskov/20220329/raw_saves/", "emit_saves": "/home/physics/smiskov/20220329/emit_saves/", "mon_saves": "/home/physics/smiskov/20220329/mon_saves/", "xopt_saves": "/home/physics/smiskov/20220329/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR2/beamline_info.json b/pyemittance/configs/LCLS_OTR2/beamline_info.json
index 3327d7a..90fb313 100644
--- a/pyemittance/configs/LCLS_OTR2/beamline_info.json
+++ b/pyemittance/configs/LCLS_OTR2/beamline_info.json
@@ -1,1 +1,1 @@
-{"energy": 0.135, "Twiss0": [1e-9, 1e-9, 1, 1, 0, 0], "rMat": [1, 2.26, 0, 1] }
\ No newline at end of file
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/LCLS_OTR2/meas_pv_info.json b/pyemittance/configs/LCLS_OTR2/meas_pv_info.json
index 6f349fb..83dd821 100644
--- a/pyemittance/configs/LCLS_OTR2/meas_pv_info.json
+++ b/pyemittance/configs/LCLS_OTR2/meas_pv_info.json
@@ -1,1 +1,1 @@
-{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "scan": "SIOC:SYS0:ML01:AO020", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR3/beamline_info.json b/pyemittance/configs/LCLS_OTR3/beamline_info.json
new file mode 100644
index 0000000..bf891b2
--- /dev/null
+++ b/pyemittance/configs/LCLS_OTR3/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 4.17, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 4.68280051, 4.68872767, -1.79636538, -1.79814306], "rMat": [1, 4.17, 0, 1] }
diff --git a/pyemittance/configs/LCLS_OTR3/img_proc.json b/pyemittance/configs/LCLS_OTR3/img_proc.json
new file mode 100644
index 0000000..3f34b53
--- /dev/null
+++ b/pyemittance/configs/LCLS_OTR3/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 200, "min_sigma": 2e-8, "max_sigma": 0.1, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR3/meas_pv_info.json b/pyemittance/configs/LCLS_OTR3/meas_pv_info.json
new file mode 100644
index 0000000..edcd0b6
--- /dev/null
+++ b/pyemittance/configs/LCLS_OTR3/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:621", "image": "OTRS:IN20:621:IMAGE", "ncol": "OTRS:IN20:621:ROI_YNP", "nrow": "OTRS:IN20:621:ROI_XNP", "resolution": "OTRS:IN20:621:RESOLUTION", "profmonxsize": "OTRS:IN20:621:XRMS", "profmonysize": "OTRS:IN20:621:YRMS", "scan": "SIOC:SYS0:ML01:AO020", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:525", "cntrl": "QUAD:IN20:525:BCTRL", "read": "QUAD:IN20:525:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
diff --git a/pyemittance/configs/LCLS_OTR3/opt_pv_info.json b/pyemittance/configs/LCLS_OTR3/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/LCLS_OTR3/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR3/save_scalar_pvs.json b/pyemittance/configs/LCLS_OTR3/save_scalar_pvs.json
new file mode 100644
index 0000000..0ff2ee1
--- /dev/null
+++ b/pyemittance/configs/LCLS_OTR3/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:621:XRMS", "OTRS:IN20:621:YRMS", "OTRS:IN20:621:X", "OTRS:IN20:621:Y", "OTRS:IN20:621:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_OTR3/savepaths.json b/pyemittance/configs/LCLS_OTR3/savepaths.json
new file mode 100644
index 0000000..7e570ec
--- /dev/null
+++ b/pyemittance/configs/LCLS_OTR3/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics3/ml_tuning/20220803/saved_fits/", "images": "/home/physics3/ml_tuning/20220803/saved_images/", "monitoring": "/home/physics3/ml_tuning/20220803/monitoring/", "summaries": "/home/physics3/ml_tuning/20220803/summaries/", "raw_saves": "/home/physics3/ml_tuning/20220803/raw_saves/", "emit_saves": "/home/physics3/ml_tuning/20220803/emit_saves/", "mon_saves": "/home/physics3/ml_tuning/20220803/mon_saves/", "xopt_saves": "/home/physics3/ml_tuning/20220803/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_WS02/beamline_info.json b/pyemittance/configs/LCLS_WS02/beamline_info.json
new file mode 100644
index 0000000..e792864
--- /dev/null
+++ b/pyemittance/configs/LCLS_WS02/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.11, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.11300768, 1.11253678, 0.06823545, 0.06691584], "rMat": [1, 2.11, 0, 1] }
diff --git a/pyemittance/configs/LCLS_WS02/img_proc.json b/pyemittance/configs/LCLS_WS02/img_proc.json
new file mode 100644
index 0000000..a75c46e
--- /dev/null
+++ b/pyemittance/configs/LCLS_WS02/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 1500, "min_sigma": 1.0, "max_sigma": 60, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_WS02/meas_pv_info.json b/pyemittance/configs/LCLS_WS02/meas_pv_info.json
new file mode 100644
index 0000000..4394ae2
--- /dev/null
+++ b/pyemittance/configs/LCLS_WS02/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "WIRE:IN20:561", "scan": "SIOC:SYS0:ML06:AO501", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:525", "cntrl": "QUAD:IN20:525:BCTRL", "read": "QUAD:IN20:525:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
diff --git a/pyemittance/configs/LCLS_WS02/opt_pv_info.json b/pyemittance/configs/LCLS_WS02/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/LCLS_WS02/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_WS02/save_scalar_pvs.json b/pyemittance/configs/LCLS_WS02/save_scalar_pvs.json
new file mode 100644
index 0000000..bd80f60
--- /dev/null
+++ b/pyemittance/configs/LCLS_WS02/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "WIRE:IN20:561:XRMS", "WIRE:IN20:561:YRMS"]}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_WS02/savepaths.json b/pyemittance/configs/LCLS_WS02/savepaths.json
new file mode 100644
index 0000000..7e570ec
--- /dev/null
+++ b/pyemittance/configs/LCLS_WS02/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics3/ml_tuning/20220803/saved_fits/", "images": "/home/physics3/ml_tuning/20220803/saved_images/", "monitoring": "/home/physics3/ml_tuning/20220803/monitoring/", "summaries": "/home/physics3/ml_tuning/20220803/summaries/", "raw_saves": "/home/physics3/ml_tuning/20220803/raw_saves/", "emit_saves": "/home/physics3/ml_tuning/20220803/emit_saves/", "mon_saves": "/home/physics3/ml_tuning/20220803/mon_saves/", "xopt_saves": "/home/physics3/ml_tuning/20220803/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/LCLS_nominal/beamline_info.json b/pyemittance/configs/LCLS_nominal/beamline_info.json
index d8b4b67..90fb313 100644
--- a/pyemittance/configs/LCLS_nominal/beamline_info.json
+++ b/pyemittance/configs/LCLS_nominal/beamline_info.json
@@ -1,1 +1,1 @@
-{"energy": 0.135, "Twiss0": [1e-06, 1e-06, 1.113081026, 1.113021659, -0.0689403587, -0.07029489754], "m_0": 0.0005110000000000001, "d": 2.26, "l": 0.108}
\ No newline at end of file
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/beamline_info.json b/pyemittance/configs/beamline_info.json
index bb7c420..90fb313 100644
--- a/pyemittance/configs/beamline_info.json
+++ b/pyemittance/configs/beamline_info.json
@@ -1,1 +1,1 @@
-{"m_0": 0.000511, "d": 2.7012, "l": 0.108, "energy": 0.125, "Twiss0": [5.3e-06, 4.9e-06, 1.1106, 1.1106, -0.0979, -0.0979], "rMat": [1, 2.7012, 0, 1] }
\ No newline at end of file
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/img_proc.json b/pyemittance/configs/img_proc.json
index d606b93..3f34b53 100644
--- a/pyemittance/configs/img_proc.json
+++ b/pyemittance/configs/img_proc.json
@@ -1,1 +1,1 @@
-{"subtract_bg": true, "use_roi": false, "avg_ims": true, "n_to_acquire": 4, "background_im":"/home/fphysics/smiskov/20220227/background_571.npy", "amp_threshold": 10, "min_sigma": 1.0, "max_sigma": 10000, "max_samples": 1, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 200, "min_sigma": 2e-8, "max_sigma": 0.1, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/make_config.ipynb b/pyemittance/configs/make_config.ipynb
deleted file mode 100644
index 46b08a1..0000000
--- a/pyemittance/configs/make_config.ipynb
+++ /dev/null
@@ -1,303 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#pv_info = json.load(open('pv_info.json'))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#pv_info"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "meas_pv_info = {'diagnostic': \n",
-    "                \n",
-    "           {'pv':\n",
-    "                {'name':'OTRS:IN20:541',\n",
-    "               'image': 'OTRS:IN20:541:IMAGE',\n",
-    "               'ncol': 'OTRS:IN20:541:ROI_YNP',\n",
-    "               'nrow': 'OTRS:IN20:541:ROI_XNP',\n",
-    "               'resolution': 'OTRS:IN20:541:RESOLUTION',\n",
-    "               'profmonxsize': 'OTRS:IN20:541:XRMS',\n",
-    "               'profmonysize': 'OTRS:IN20:541:YRMS'},\n",
-    "            \n",
-    "            'pv_unit':{'resolution':'(um)'}},\n",
-    "           \n",
-    "                           \n",
-    "       'meas_device':\n",
-    "                \n",
-    "           {'pv':\n",
-    "                {'name':'QUAD:IN20:425',\n",
-    "                 'cntrl':'QUAD:IN20:425:BCTRL',\n",
-    "                 'read': 'QUAD:IN20:425:BACT'},\n",
-    "            'pv_unit': ('kG')},\n",
-    "           \n",
-    "       'beam_info':\n",
-    "               {'energy':'REFS:IN20:751:EDES'}}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "opt_pv_info = {\n",
-    "           'opt_vars': ['SOLN:IN20:121:BCTRL',\n",
-    "                       'QUAD:IN20:121:BCTRL',\n",
-    "                       'QUAD:IN20:122:BCTRL',\n",
-    "                       'QUAD:IN20:361:BCTRL',\n",
-    "                       'QUAD:IN20:371:BCTRL',\n",
-    "                       'QUAD:IN20:425:BCTRL',\n",
-    "                       'QUAD:IN20:441:BCTRL',\n",
-    "                       'QUAD:IN20:511:BCTRL',\n",
-    "                       'QUAD:IN20:525:BCTRL'],\n",
-    "            'opt_var_units':\n",
-    "                      ['(kG*m)',\n",
-    "                       '(kG)',\n",
-    "                      '(kG)',\n",
-    "                      '(kG)',\n",
-    "                      '(kG)',\n",
-    "                      '(kG)',\n",
-    "                      '(kG)',\n",
-    "                      '(kG)',\n",
-    "                      '(kG)'],\n",
-    "            \n",
-    "            'input_vars':[]}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "rootp = '/home/physics/smiskov/20220203'\n",
-    "savepaths = {\n",
-    "           'fits': rootp+'/saved_fits/',\n",
-    "            'images':rootp+'/saved_images/',\n",
-    "            'monitoring':rootp+'/monitoring/',\n",
-    "            'summaries':rootp+'/summaries/',\n",
-    "            'raw_saves':rootp+'/raw_saves/',\n",
-    "            'emit_saves':rootp+'/emit_saves/',\n",
-    "            'mon_saves':rootp+'/mon_saves/',\n",
-    "            'xopt_saves':rootp+'/xopt_saves/'}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "img_proc = {\n",
-    "           'subtract_bg': False,\n",
-    "            'use_roi':False,\n",
-    "            'avg_ims':True,\n",
-    "            'n_to_acquire':5,\n",
-    "            'background_im':None,\n",
-    "            'amp_threshold':1500,\n",
-    "            'min_sigma':1.0,\n",
-    "            'max_sigma':60,\n",
-    "            'max_samples':3,\n",
-    "            'roi':{'xmin':0,'xmax':100,'ymin':0,'ymax':100}}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "beamline_info = {\n",
-    "                'energy':0.135,\n",
-    "                'Twiss0':[1e-6, 1e-6, 4.16157667e+00, 4.16157699e+00, 1.66328017e+00, 1.66328028e+00]\n",
-    "}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "pvname_list = {'scalars': ['SOLN:IN20:121:BACT',  \n",
-    "       'QUAD:IN20:121:BACT',  \n",
-    "       'QUAD:IN20:122:BACT', \n",
-    "\n",
-    "        \"QUAD:IN20:361:BACT\",\n",
-    "        \"QUAD:IN20:371:BACT\",\n",
-    "        \"QUAD:IN20:425:BACT\",\n",
-    "        \"QUAD:IN20:441:BACT\",\n",
-    "        \"QUAD:IN20:511:BACT\",\n",
-    "        \"QUAD:IN20:525:BACT\",\n",
-    "               \n",
-    "        'SOLN:IN20:121:BCTRL', \n",
-    "       'QUAD:IN20:121:BCTRL', \n",
-    "       'QUAD:IN20:122:BCTRL',\n",
-    "               \n",
-    "        \"QUAD:IN20:361:BCTRL\",\n",
-    "        \"QUAD:IN20:371:BCTRL\",\n",
-    "        \"QUAD:IN20:425:BCTRL\",\n",
-    "        \"QUAD:IN20:441:BCTRL\",\n",
-    "        \"QUAD:IN20:511:BCTRL\",\n",
-    "        \"QUAD:IN20:525:BCTRL\",\n",
-    "\n",
-    "       'OTRS:IN20:541:XRMS',\n",
-    "       'OTRS:IN20:541:YRMS',\n",
-    "       'OTRS:IN20:541:X',\n",
-    "       'OTRS:IN20:541:Y',\n",
-    "               'OTRS:IN20:541:RESOLUTION']}\n",
-    "#        'TORO:IN20:791:0:TMIT_PC',\n",
-    "#                'PROF:IN20:571:RESOLUTION',\n",
-    "#                'CAMR:LT10:900:RESOLUTION',\n",
-    "#                'PROF:IN20:571:Image:ArraySize0_RBV',\n",
-    "#                'PROF:IN20:571:Image:ArraySize1_RBV',\n",
-    "#                \"CAMR:LT10:900:Image:ArraySize0_RBV\",\n",
-    "#                 \"CAMR:LT10:900:Image:ArraySize1_RBV\"]}\n",
-    "\n",
-    "with open('save_scalar_pvs.json', 'w') as outfile:\n",
-    "    json.dump(pvname_list, outfile)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 102,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "\n",
-    "# ts = isotime()\n",
-    "# x = epics.caget_many(pvname_list)\n",
-    "# img=epics.caget('PROF:IN10:571:Image:ArrayData')\n",
-    "# nrow = epics.caget('PROF:IN10:571:Image:ArraySize0_RBV')\n",
-    "# ncol = epics.caget('PROF:IN10:571:Image:ArraySize1_RBV')    \n",
-    "\n",
-    "# res = epics.caget('PROF:IN10:571:RESOLUTION')\n",
-    "\n",
-    "# nrow1 = caget(\"CAMR:LT10:900:Image:ArraySize0_RBV\")\n",
-    "# ncol1 = caget(\"CAMR:LT10:900:Image:ArraySize1_RBV\")\n",
-    "\n",
-    "# resolution1 = caget(\"CAMR:LT10:900:RESOLUTION\")\n",
-    "# img1 =caget('CAMR:LT10:900:Image:ArrayData')\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "with open('savepaths.json', 'w') as outfile:\n",
-    "    json.dump(savepaths, outfile)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open('meas_pv_info.json', 'w') as outfile:\n",
-    "    json.dump(meas_pv_info, outfile)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open('opt_pv_info.json', 'w') as outfile:\n",
-    "    json.dump(opt_pv_info, outfile)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open('img_proc.json', 'w') as outfile:\n",
-    "    json.dump(img_proc, outfile)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "with open('beamline_info.json', 'w') as outfile:\n",
-    "    json.dump(beamline_info, outfile)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.11"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/pyemittance/configs/meas_pv_info.json b/pyemittance/configs/meas_pv_info.json
index 796b41c..6f349fb 100644
--- a/pyemittance/configs/meas_pv_info.json
+++ b/pyemittance/configs/meas_pv_info.json
@@ -1,1 +1,1 @@
-{"diagnostic": {"pv": {"name": "PROF:IN10:571", "image": "PROF:IN10:571:Image:ArrayData", "ncol": "PROF:IN10:571:Image:ArraySize1_RBV", "nrow": "PROF:IN10:571:Image:ArraySize0_RBV", "resolution": "PROF:IN10:571:RESOLUTION", "profmonxsize": "PROF:IN10:571:XRMS", "profmonysize": "PROF:IN10:571:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN10:525", "cntrl": "QUAD:IN10:525:BCTRL", "read": "QUAD:IN10:525:BACT","min":-8.5,"max":-2.0}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN10:751:EDES"}}
\ No newline at end of file
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/opt_pv_info.json b/pyemittance/configs/opt_pv_info.json
index 00ed2d4..58a6c12 100644
--- a/pyemittance/configs/opt_pv_info.json
+++ b/pyemittance/configs/opt_pv_info.json
@@ -1,1 +1,1 @@
-{"opt_vars": ["SOLN:IN10:121:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/FACET_nominal/beamline_info.json b/pyemittance/configs/other_configs/FACET_nominal/beamline_info.json
new file mode 100644
index 0000000..ebef231
--- /dev/null
+++ b/pyemittance/configs/other_configs/FACET_nominal/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "FACET-II", "m_0": 0.000511, "d": 2.7012, "l": 0.108, "energy": 0.125, "Twiss0": [5.3e-06, 4.9e-06, 1.1106, 1.1106, -0.0979, -0.0979], "rMat": [1, 2.7012, 0, 1] }
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/FACET_nominal/img_proc.json b/pyemittance/configs/other_configs/FACET_nominal/img_proc.json
new file mode 100644
index 0000000..e12eae3
--- /dev/null
+++ b/pyemittance/configs/other_configs/FACET_nominal/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": true, "use_roi": false, "avg_ims": true, "n_to_acquire": 4, "background_im":"/home/fphysics/edelen/sw/lcls_emit/background_571.npy", "amp_threshold": 1000, "min_sigma": 1.0, "max_sigma": 1000, "max_samples": 1, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/FACET_nominal/meas_pv_info.json b/pyemittance/configs/other_configs/FACET_nominal/meas_pv_info.json
new file mode 100644
index 0000000..796b41c
--- /dev/null
+++ b/pyemittance/configs/other_configs/FACET_nominal/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "PROF:IN10:571", "image": "PROF:IN10:571:Image:ArrayData", "ncol": "PROF:IN10:571:Image:ArraySize1_RBV", "nrow": "PROF:IN10:571:Image:ArraySize0_RBV", "resolution": "PROF:IN10:571:RESOLUTION", "profmonxsize": "PROF:IN10:571:XRMS", "profmonysize": "PROF:IN10:571:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN10:525", "cntrl": "QUAD:IN10:525:BCTRL", "read": "QUAD:IN10:525:BACT","min":-8.5,"max":-2.0}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN10:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/FACET_nominal/opt_pv_info.json b/pyemittance/configs/other_configs/FACET_nominal/opt_pv_info.json
new file mode 100644
index 0000000..00ed2d4
--- /dev/null
+++ b/pyemittance/configs/other_configs/FACET_nominal/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN10:121:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/FACET_nominal/save_scalar_pvs.json b/pyemittance/configs/other_configs/FACET_nominal/save_scalar_pvs.json
new file mode 100644
index 0000000..066938e
--- /dev/null
+++ b/pyemittance/configs/other_configs/FACET_nominal/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN10:121:BACT", "SOLN:IN10:111:BACT", "QUAD:IN10:121:BACT", "QUAD:IN10:122:BACT", "QUAD:IN10:361:BACT", "QUAD:IN10:371:BACT", "QUAD:IN10:425:BACT", "QUAD:IN10:441:BACT", "QUAD:IN10:511:BACT", "QUAD:IN10:525:BACT", "SOLN:IN10:121:BCTRL", "SOLN:IN10:111:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL", "KLYS:LI10:21:PHAS", "KLYS:LI10:21:AMPL", "KLYS:LI10:51:PHAS", "PROF:IN10:571:XRMS", "PROF:IN10:571:YRMS", "PROF:IN10:571:X", "PROF:IN10:571:Y", "TORO:IN10:791:0:TMIT_PC", "PROF:IN10:571:RESOLUTION", "CAMR:LT10:900:RESOLUTION", "PROF:IN10:571:Image:ArraySize0_RBV", "PROF:IN10:571:Image:ArraySize1_RBV", "CAMR:LT10:900:Image:ArraySize0_RBV", "CAMR:LT10:900:Image:ArraySize1_RBV"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/FACET_nominal/savepaths.json b/pyemittance/configs/other_configs/FACET_nominal/savepaths.json
new file mode 100644
index 0000000..41614f1
--- /dev/null
+++ b/pyemittance/configs/other_configs/FACET_nominal/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/fphysics/edelen/20211210/saved_fits/", "images": "/home/fphysics/edelen/20211210/saved_images/", "monitoring": "/home/fphysics/edelen/20211210/monitoring/", "summaries": "/home/fphysics/edelen/20211210/summaries/", "raw_saves": "/home/fphysics/edelen/20211210/raw_saves/", "emit_saves": "/home/fphysics/edelen/20211210/emit_saves/", "mon_saves": "/home/fphysics/edelen/20211210/mon_saves/", "xopt_saves": "/home/fphysics/edelen/20211210/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR1/beamline_info.json b/pyemittance/configs/other_configs/LCLS_OTR1/beamline_info.json
new file mode 100644
index 0000000..fb1c029
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR1/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-06, 1e-06, 4.16157667, 4.16157699, 1.66328017, 1.66328028], "rMat": [1.1055070102091, 2.74258378560201, -0.213608624301716, 0.374633943250189] }
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR1/img_proc.json b/pyemittance/configs/other_configs/LCLS_OTR1/img_proc.json
new file mode 100644
index 0000000..a75c46e
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR1/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 1500, "min_sigma": 1.0, "max_sigma": 60, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR1/meas_pv_info.json b/pyemittance/configs/other_configs/LCLS_OTR1/meas_pv_info.json
new file mode 100644
index 0000000..127f4c5
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR1/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS", "scan": "SIOC:SYS0:ML01:AO020", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR1/opt_pv_info.json b/pyemittance/configs/other_configs/LCLS_OTR1/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR1/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR1/save_scalar_pvs.json b/pyemittance/configs/other_configs/LCLS_OTR1/save_scalar_pvs.json
new file mode 100644
index 0000000..cdb22dc
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR1/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:541:XRMS", "OTRS:IN20:541:YRMS", "OTRS:IN20:541:X", "OTRS:IN20:541:Y", "OTRS:IN20:541:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR1/savepaths.json b/pyemittance/configs/other_configs/LCLS_OTR1/savepaths.json
new file mode 100644
index 0000000..5151a1f
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR1/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics/smiskov/20220329/saved_fits/", "images": "/home/physics/smiskov/20220329/saved_images/", "monitoring": "/home/physics/smiskov/20220329/monitoring/", "summaries": "/home/physics/smiskov/20220329/summaries/", "raw_saves": "/home/physics/smiskov/20220329/raw_saves/", "emit_saves": "/home/physics/smiskov/20220329/emit_saves/", "mon_saves": "/home/physics/smiskov/20220329/mon_saves/", "xopt_saves": "/home/physics/smiskov/20220329/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR2/beamline_info.json b/pyemittance/configs/other_configs/LCLS_OTR2/beamline_info.json
new file mode 100644
index 0000000..90fb313
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR2/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/other_configs/LCLS_OTR2/img_proc.json b/pyemittance/configs/other_configs/LCLS_OTR2/img_proc.json
new file mode 100644
index 0000000..a75c46e
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR2/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 1500, "min_sigma": 1.0, "max_sigma": 60, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR2/meas_pv_info.json b/pyemittance/configs/other_configs/LCLS_OTR2/meas_pv_info.json
new file mode 100644
index 0000000..83dd821
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR2/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "scan": "SIOC:SYS0:ML01:AO020", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR2/opt_pv_info.json b/pyemittance/configs/other_configs/LCLS_OTR2/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR2/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR2/save_scalar_pvs.json b/pyemittance/configs/other_configs/LCLS_OTR2/save_scalar_pvs.json
new file mode 100644
index 0000000..cdb22dc
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR2/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:541:XRMS", "OTRS:IN20:541:YRMS", "OTRS:IN20:541:X", "OTRS:IN20:541:Y", "OTRS:IN20:541:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR2/savepaths.json b/pyemittance/configs/other_configs/LCLS_OTR2/savepaths.json
new file mode 100644
index 0000000..119b551
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR2/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics/smiskov/20220203/saved_fits/", "images": "/home/physics/smiskov/20220203/saved_images/", "monitoring": "/home/physics/smiskov/20220203/monitoring/", "summaries": "/home/physics/smiskov/20220203/summaries/", "raw_saves": "/home/physics/smiskov/20220203/raw_saves/", "emit_saves": "/home/physics/smiskov/20220203/emit_saves/", "mon_saves": "/home/physics/smiskov/20220203/mon_saves/", "xopt_saves": "/home/physics/smiskov/20220203/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR3/beamline_info.json b/pyemittance/configs/other_configs/LCLS_OTR3/beamline_info.json
new file mode 100644
index 0000000..bf891b2
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR3/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 4.17, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 4.68280051, 4.68872767, -1.79636538, -1.79814306], "rMat": [1, 4.17, 0, 1] }
diff --git a/pyemittance/configs/other_configs/LCLS_OTR3/img_proc.json b/pyemittance/configs/other_configs/LCLS_OTR3/img_proc.json
new file mode 100644
index 0000000..7dd6f8e
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR3/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": true, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": "/home/physics3/ml_tuning/20220803/saved_images/img_avg_2022-08-03_12-56-32-031959.npy", "amp_threshold": 1000, "min_sigma": 2e-10, "max_sigma": 100, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR3/meas_pv_info.json b/pyemittance/configs/other_configs/LCLS_OTR3/meas_pv_info.json
new file mode 100644
index 0000000..edcd0b6
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR3/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:621", "image": "OTRS:IN20:621:IMAGE", "ncol": "OTRS:IN20:621:ROI_YNP", "nrow": "OTRS:IN20:621:ROI_XNP", "resolution": "OTRS:IN20:621:RESOLUTION", "profmonxsize": "OTRS:IN20:621:XRMS", "profmonysize": "OTRS:IN20:621:YRMS", "scan": "SIOC:SYS0:ML01:AO020", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:525", "cntrl": "QUAD:IN20:525:BCTRL", "read": "QUAD:IN20:525:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
diff --git a/pyemittance/configs/other_configs/LCLS_OTR3/opt_pv_info.json b/pyemittance/configs/other_configs/LCLS_OTR3/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR3/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR3/save_scalar_pvs.json b/pyemittance/configs/other_configs/LCLS_OTR3/save_scalar_pvs.json
new file mode 100644
index 0000000..0ff2ee1
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR3/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:621:XRMS", "OTRS:IN20:621:YRMS", "OTRS:IN20:621:X", "OTRS:IN20:621:Y", "OTRS:IN20:621:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_OTR3/savepaths.json b/pyemittance/configs/other_configs/LCLS_OTR3/savepaths.json
new file mode 100644
index 0000000..7e570ec
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_OTR3/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics3/ml_tuning/20220803/saved_fits/", "images": "/home/physics3/ml_tuning/20220803/saved_images/", "monitoring": "/home/physics3/ml_tuning/20220803/monitoring/", "summaries": "/home/physics3/ml_tuning/20220803/summaries/", "raw_saves": "/home/physics3/ml_tuning/20220803/raw_saves/", "emit_saves": "/home/physics3/ml_tuning/20220803/emit_saves/", "mon_saves": "/home/physics3/ml_tuning/20220803/mon_saves/", "xopt_saves": "/home/physics3/ml_tuning/20220803/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_WS02/beamline_info.json b/pyemittance/configs/other_configs/LCLS_WS02/beamline_info.json
new file mode 100644
index 0000000..e792864
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_WS02/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.11, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.11300768, 1.11253678, 0.06823545, 0.06691584], "rMat": [1, 2.11, 0, 1] }
diff --git a/pyemittance/configs/other_configs/LCLS_WS02/img_proc.json b/pyemittance/configs/other_configs/LCLS_WS02/img_proc.json
new file mode 100644
index 0000000..a75c46e
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_WS02/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 1500, "min_sigma": 1.0, "max_sigma": 60, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_WS02/meas_pv_info.json b/pyemittance/configs/other_configs/LCLS_WS02/meas_pv_info.json
new file mode 100644
index 0000000..4394ae2
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_WS02/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "WIRE:IN20:561", "scan": "SIOC:SYS0:ML06:AO501", "xsize": "WIRE:IN20:561:XRMS", "ysize": "WIRE:IN20:561:YRMS", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:525", "cntrl": "QUAD:IN20:525:BCTRL", "read": "QUAD:IN20:525:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
diff --git a/pyemittance/configs/other_configs/LCLS_WS02/opt_pv_info.json b/pyemittance/configs/other_configs/LCLS_WS02/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_WS02/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_WS02/save_scalar_pvs.json b/pyemittance/configs/other_configs/LCLS_WS02/save_scalar_pvs.json
new file mode 100644
index 0000000..bd80f60
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_WS02/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "WIRE:IN20:561:XRMS", "WIRE:IN20:561:YRMS"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_WS02/savepaths.json b/pyemittance/configs/other_configs/LCLS_WS02/savepaths.json
new file mode 100644
index 0000000..7e570ec
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_WS02/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics3/ml_tuning/20220803/saved_fits/", "images": "/home/physics3/ml_tuning/20220803/saved_images/", "monitoring": "/home/physics3/ml_tuning/20220803/monitoring/", "summaries": "/home/physics3/ml_tuning/20220803/summaries/", "raw_saves": "/home/physics3/ml_tuning/20220803/raw_saves/", "emit_saves": "/home/physics3/ml_tuning/20220803/emit_saves/", "mon_saves": "/home/physics3/ml_tuning/20220803/mon_saves/", "xopt_saves": "/home/physics3/ml_tuning/20220803/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_nominal/beamline_info.json b/pyemittance/configs/other_configs/LCLS_nominal/beamline_info.json
new file mode 100644
index 0000000..90fb313
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_nominal/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/other_configs/LCLS_nominal/img_proc.json b/pyemittance/configs/other_configs/LCLS_nominal/img_proc.json
new file mode 100644
index 0000000..1a925c3
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_nominal/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 2, "background_im": null, "amp_threshold": 1500, "min_sigma": 1.0, "max_sigma": 60, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_nominal/meas_pv_info.json b/pyemittance/configs/other_configs/LCLS_nominal/meas_pv_info.json
new file mode 100644
index 0000000..3214f60
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_nominal/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:571", "image": "OTRS:IN20:571:IMAGE", "ncol": "OTRS:IN20:571:ROI_YNP", "nrow": "OTRS:IN20:571:ROI_XNP", "resolution": "OTRS:IN20:571:RESOLUTION", "profmonxsize": "OTRS:IN20:571:XRMS", "profmonysize": "OTRS:IN20:571:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:525", "cntrl": "QUAD:IN20:525:BCTRL", "read": "QUAD:IN20:525:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_nominal/opt_pv_info.json b/pyemittance/configs/other_configs/LCLS_nominal/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_nominal/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_nominal/pv_info.json b/pyemittance/configs/other_configs/LCLS_nominal/pv_info.json
new file mode 100644
index 0000000..f0cbf61
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_nominal/pv_info.json
@@ -0,0 +1,42 @@
+{
+   "device":{
+      "OTR2":{
+         "pvname":"OTRS:IN20:571",
+         "image":"OTRS:IN20:571:IMAGE",
+         "ncol":"OTRS:IN20:571:ROI_YNP",
+         "nrow":"OTRS:IN20:571:ROI_XNP",
+         "resolution":"OTRS:IN20:571:RESOLUTION",
+         "profmonxsize":"OTRS:IN20:571:XRMS",
+         "profmonysize":"OTRS:IN20:571:YRMS"
+      },
+      "SOL":{
+         "SOL121":"SOLN:IN20:121:BCTRL"
+      },
+      "QUAD":{
+         "Q121":"QUAD:IN20:121:BCTRL",
+         "Q122":"QUAD:IN20:122:BCTRL",
+         "Q361":"QUAD:IN20:361:BCTRL",
+         "Q371":"QUAD:IN20:371:BCTRL",
+         "Q425":"QUAD:IN20:425:BCTRL",
+         "Q441":"QUAD:IN20:441:BCTRL",
+         "Q511":"QUAD:IN20:511:BCTRL",
+         "Q525":"QUAD:IN20:525:BCTRL"
+      }
+   },"pv_unit":{
+      "OTRS:IN20:571:RESOLUTION":"(um)",
+      "SOLN:IN20:121:BCTRL":"(kG*m)",
+      "QUAD:IN20:121:BCTRL":"(kG)",
+      "QUAD:IN20:122:BCTRL":"(kG)",
+      "QUAD:IN20:361:BCTRL":"(kG)",
+      "QUAD:IN20:371:BCTRL":"(kG)",
+      "QUAD:IN20:425:BCTRL":"(kG)",
+      "QUAD:IN20:441:BCTRL":"(kG)",
+      "QUAD:IN20:511:BCTRL":"(kG)",
+      "QUAD:IN20:525:BCTRL":"(kG)"
+   },"energy":{
+      "gun":"REFS:IN20:231:EDES",
+      "DL1":"REFS:IN20:751:EDES",
+      "Q631":"QUAD:IN20:631:EDES",
+      "B751":"BEND:IN20:751:EDES"
+   }
+}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/LCLS_nominal/savepaths.json b/pyemittance/configs/other_configs/LCLS_nominal/savepaths.json
new file mode 100644
index 0000000..69554e8
--- /dev/null
+++ b/pyemittance/configs/other_configs/LCLS_nominal/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "./saved_fits/", "images": "./saved_images/", "monitoring": "./monitoring/", "summaries": "./summaries/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/sim/beamline_info.json b/pyemittance/configs/other_configs/sim/beamline_info.json
new file mode 100644
index 0000000..90fb313
--- /dev/null
+++ b/pyemittance/configs/other_configs/sim/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/other_configs/sim/img_proc.json b/pyemittance/configs/other_configs/sim/img_proc.json
new file mode 100644
index 0000000..3f34b53
--- /dev/null
+++ b/pyemittance/configs/other_configs/sim/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 200, "min_sigma": 2e-8, "max_sigma": 0.1, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/sim/meas_pv_info.json b/pyemittance/configs/other_configs/sim/meas_pv_info.json
new file mode 100644
index 0000000..6f349fb
--- /dev/null
+++ b/pyemittance/configs/other_configs/sim/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/sim/opt_pv_info.json b/pyemittance/configs/other_configs/sim/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/other_configs/sim/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/sim/save_scalar_pvs.json b/pyemittance/configs/other_configs/sim/save_scalar_pvs.json
new file mode 100644
index 0000000..cdb22dc
--- /dev/null
+++ b/pyemittance/configs/other_configs/sim/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:541:XRMS", "OTRS:IN20:541:YRMS", "OTRS:IN20:541:X", "OTRS:IN20:541:Y", "OTRS:IN20:541:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/sim/savepaths.json b/pyemittance/configs/other_configs/sim/savepaths.json
new file mode 100644
index 0000000..119b551
--- /dev/null
+++ b/pyemittance/configs/other_configs/sim/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics/smiskov/20220203/saved_fits/", "images": "/home/physics/smiskov/20220203/saved_images/", "monitoring": "/home/physics/smiskov/20220203/monitoring/", "summaries": "/home/physics/smiskov/20220203/summaries/", "raw_saves": "/home/physics/smiskov/20220203/raw_saves/", "emit_saves": "/home/physics/smiskov/20220203/emit_saves/", "mon_saves": "/home/physics/smiskov/20220203/mon_saves/", "xopt_saves": "/home/physics/smiskov/20220203/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/save_scalar_pvs.json b/pyemittance/configs/save_scalar_pvs.json
index 066938e..cdb22dc 100644
--- a/pyemittance/configs/save_scalar_pvs.json
+++ b/pyemittance/configs/save_scalar_pvs.json
@@ -1,1 +1,1 @@
-{"scalars": ["SOLN:IN10:121:BACT", "SOLN:IN10:111:BACT", "QUAD:IN10:121:BACT", "QUAD:IN10:122:BACT", "QUAD:IN10:361:BACT", "QUAD:IN10:371:BACT", "QUAD:IN10:425:BACT", "QUAD:IN10:441:BACT", "QUAD:IN10:511:BACT", "QUAD:IN10:525:BACT", "SOLN:IN10:121:BCTRL", "SOLN:IN10:111:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL", "KLYS:LI10:21:PHAS", "KLYS:LI10:21:AMPL", "KLYS:LI10:51:PHAS", "PROF:IN10:571:XRMS", "PROF:IN10:571:YRMS", "PROF:IN10:571:X", "PROF:IN10:571:Y", "TORO:IN10:791:0:TMIT_PC", "PROF:IN10:571:RESOLUTION", "CAMR:LT10:900:RESOLUTION", "PROF:IN10:571:Image:ArraySize0_RBV", "PROF:IN10:571:Image:ArraySize1_RBV", "CAMR:LT10:900:Image:ArraySize0_RBV", "CAMR:LT10:900:Image:ArraySize1_RBV"]}
\ No newline at end of file
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:541:XRMS", "OTRS:IN20:541:YRMS", "OTRS:IN20:541:X", "OTRS:IN20:541:Y", "OTRS:IN20:541:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/savepaths.json b/pyemittance/configs/savepaths.json
index abe22e8..7e570ec 100644
--- a/pyemittance/configs/savepaths.json
+++ b/pyemittance/configs/savepaths.json
@@ -1,1 +1,1 @@
-{"fits": "/home/fphysics/smiskov/20220227/saved_fits/", "images": "/home/fphysics/smiskov/20220227/saved_images/", "monitoring": "/home/fphysics/smiskov/20220227/monitoring/", "summaries": "/home/fphysics/smiskov/20220227/summaries/", "raw_saves": "/home/fphysics/smiskov/20220227/raw_saves/", "emit_saves": "/home/fphysics/smiskov/20220227/emit_saves/", "mon_saves": "/home/fphysics/smiskov/20220227/mon_saves/", "xopt_saves": "/home/fphysics/smiskov/20220227/xopt_saves/"}
\ No newline at end of file
+{"fits": "/home/physics3/ml_tuning/20220803/saved_fits/", "images": "/home/physics3/ml_tuning/20220803/saved_images/", "monitoring": "/home/physics3/ml_tuning/20220803/monitoring/", "summaries": "/home/physics3/ml_tuning/20220803/summaries/", "raw_saves": "/home/physics3/ml_tuning/20220803/raw_saves/", "emit_saves": "/home/physics3/ml_tuning/20220803/emit_saves/", "mon_saves": "/home/physics3/ml_tuning/20220803/mon_saves/", "xopt_saves": "/home/physics3/ml_tuning/20220803/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/sim/beamline_info.json b/pyemittance/configs/sim/beamline_info.json
new file mode 100644
index 0000000..90fb313
--- /dev/null
+++ b/pyemittance/configs/sim/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/sim/img_proc.json b/pyemittance/configs/sim/img_proc.json
new file mode 100644
index 0000000..3f34b53
--- /dev/null
+++ b/pyemittance/configs/sim/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 200, "min_sigma": 2e-8, "max_sigma": 0.1, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/sim/meas_pv_info.json b/pyemittance/configs/sim/meas_pv_info.json
new file mode 100644
index 0000000..6f349fb
--- /dev/null
+++ b/pyemittance/configs/sim/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/sim/opt_pv_info.json b/pyemittance/configs/sim/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/sim/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/sim/save_scalar_pvs.json b/pyemittance/configs/sim/save_scalar_pvs.json
new file mode 100644
index 0000000..cdb22dc
--- /dev/null
+++ b/pyemittance/configs/sim/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:541:XRMS", "OTRS:IN20:541:YRMS", "OTRS:IN20:541:X", "OTRS:IN20:541:Y", "OTRS:IN20:541:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/sim/savepaths.json b/pyemittance/configs/sim/savepaths.json
new file mode 100644
index 0000000..119b551
--- /dev/null
+++ b/pyemittance/configs/sim/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics/smiskov/20220203/saved_fits/", "images": "/home/physics/smiskov/20220203/saved_images/", "monitoring": "/home/physics/smiskov/20220203/monitoring/", "summaries": "/home/physics/smiskov/20220203/summaries/", "raw_saves": "/home/physics/smiskov/20220203/raw_saves/", "emit_saves": "/home/physics/smiskov/20220203/emit_saves/", "mon_saves": "/home/physics/smiskov/20220203/mon_saves/", "xopt_saves": "/home/physics/smiskov/20220203/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/data_handler.py b/pyemittance/data_handler.py
index f72c7df..af018cd 100644
--- a/pyemittance/data_handler.py
+++ b/pyemittance/data_handler.py
@@ -2,21 +2,31 @@
 import numpy as np
 from scipy.optimize import curve_fit
 from pyemittance.optics import get_k1, get_gradient, get_quad_field
-# on sim
-# from beam_io_sim import get_beamsizes
-# on lcls
-# from beam_io import get_beamsizes, setquad, quad_control
+from pyemittance.machine_settings import get_energy
+
 # TODO: import m_0
 m_0  = 0.000511
 
-def adapt_range(x, y, axis, w=None, energy=0.135,
-                cutoff_percent=0.3, num_points=5,
-                save_plot=False, show_plots=True):
+def adapt_range(x, y, axis, w=None, energy=get_energy(), cutoff_percent=0.3,
+                num_points=5, verbose=False):
     """Returns new scan quad values AS LIST"""
     x = np.array(x)
     y = np.array(y)
     if w is not None:
         w = np.array(w)
+        
+#     print("x ", x)
+#     print("y ", y)
+    
+    idx = ~np.isnan(y)
+
+    if True not in idx:
+        print("no valid pnts")
+        return x
+    x = x[idx]
+    y = y[idx]
+    if w is not None:
+        w = w[idx]
 
     # Remove points that are too large
     # Do this only if bs more than double from min
@@ -48,10 +58,13 @@ def adapt_range(x, y, axis, w=None, energy=0.135,
     min_x, max_x = x.min(), x.max()
 
     # we need a poly fit here to find roots, poly_ylim, etc
-    fit_coefs, fit_cov = curve_fit(func, x, y ** 2, sigma=w, absolute_sigma=True, method='trf')
+    y_squared = y*y
+
+    
+    fit_coefs, fit_cov = curve_fit(func, x, y_squared)
 
     # space over which to fit
-    x_fit = np.linspace(min_x, max_x, 100)
+    x_fit = np.linspace(min_x, max_x, 25)
 
     # no more restrictions on quad vals, just staying within
     # the region already scanned (can increase this if need be)
@@ -60,7 +73,8 @@ def adapt_range(x, y, axis, w=None, energy=0.135,
     c2, c1, c0 = fit_coefs
 
     if c2 < 0: # same if s11q is negative
-        print("Adjusting concave poly.")
+        if verbose:
+            print("Adjusting concave poly.")
         # go to lower side of concave polynomials
         # (assuming it is closer to the local minimum)
         x_min_concave = x[np.argmin(y)]
@@ -150,20 +164,17 @@ def check_symmetry(x, y, y_err, axis, bs_fn=None, add_meas=False):
         return add_to_side, x_add
 
 
-def add_measurements(add_to_side, x_add, x, y, y_err, axis, bs_fn=None):
+def add_measurements(add_to_side, x_add, x, y, y_err, axis, bs_fn):
     """Add beamsize measurements on left or right side based on
     symmetry of scan curve.
     x_add are the quad scan values k in units of 1/m^2"""
-
-    if not bs_fn:
-        return None
     
     # get new data points
     idx_size = 1 if axis == "y" else 0
     idx_err = 3 if axis == "y" else 2
     new_data = bs_fn(x_add)
     y_add, y_err_add = new_data[idx_size], new_data[idx_err]
-        
+
     # then append to existing dataset
     if add_to_side == "left":
         new_x_list = list(x_add) + list(x)
@@ -173,15 +184,16 @@ def add_measurements(add_to_side, x_add, x, y, y_err, axis, bs_fn=None):
         new_x_list = list(x) + list(x_add)
         new_y_list = list(y) + list(y_add)
         new_y_err_list = list(y_err) + list(y_err_add)
-            
+
     return new_x_list, new_y_list, new_y_err_list
 
 
-def find_inflection_pnt(x, y, show_plots=True):
+def find_inflection_pnt(x, y, show_plots=True, save_plots=False):
     """Find inflection points in curve and remove
     points outside of convex region around min"""
 
-    y = np.array(y)**2 # since we are fitting sizes**2
+    y = np.array(y)
+    y = y*y # since we are fitting sizes**2
 
     # compute second derivative
     y_d2 = np.gradient(np.gradient(y))
@@ -207,9 +219,10 @@ def find_inflection_pnt(x, y, show_plots=True):
             right = infls
         infls = np.array([infls])
 
+
     elif len(infls)>1:
         # cut it down to 2 closest to min
-        if ( np.argmin(y) in infls and len(infls > 2) ) or ( np.argmin(y) not in infls ):
+        if ( np.argmin(y) in infls and len(infls) > 2 ) or ( np.argmin(y) not in infls ):
             if np.argmin(y) in infls:
                 infls = list(infls)
                 infls.remove(np.argmin(y))
@@ -254,29 +267,106 @@ def find_inflection_pnt(x, y, show_plots=True):
         y_new, x_new = y[left:right], x[left:right]
 
         import matplotlib.pyplot as plt
+        #plt.figure(figsize=(8,6))
+        #plt.figure(figsize=(5, 4))
         from numpy.polynomial import polynomial as P
 
         x_fit = np.linspace(np.min(x), np.max(x), 50)
+
         # original polynomial for visuals
         c, stats = P.polyfit(x, y, 2, full=True)
-        plt.plot(x_fit, P.polyval(x_fit,c))
-        # updated polynomial for visuals
-        c, stats = P.polyfit(x_new, y_new, 2, full=True)
-        plt.plot(x_fit, P.polyval(x_fit, c), color="blue", linestyle="--")
+        plt.plot(x_fit, P.polyval(x_fit, c) / 1e-6, color='gray', linestyle="--")
+
+        plt.scatter(x, np.asarray(y) / 1e-6, color='gray', label='Data')
+
         # remove nones from infls
-        infls  = filter(None, infls)
+        infls = filter(None, infls)
         # plot the location of each inflection point
         for i, infl in enumerate(infls, 1):
-            plt.axvline(x=x[infl], color='gray', label=f'Inflection Point {i}', linestyle="--" )
-        plt.scatter(x, y)
-        plt.scatter(x_new, y_new, color="blue", label="Use")
-        plt.ylim(None, np.max(y)*1.3)
-        plt.legend()
+            if i == 1:
+                plt.axvline(x=x[infl], color='black', label=f'Inflection Point', linestyle="--", alpha=0.5)
+            else:
+                plt.axvline(x=x[infl], color='black', linestyle="--", alpha=0.5)
+
+        # updated polynomial for visuals
+        c, stats = P.polyfit(x_new, y_new, 2, full=True)
+        plt.plot(x_fit, P.polyval(x_fit, c) / 1e-6, color='C0', linestyle="--")
+
+        plt.scatter(x_new, y_new / 1e-6, color="C0", label="Use")
+
+        plt.ylim(None, np.max(y) * 1.3 / 1e-6)
+        plt.xlabel('Quadrupole Strength (kG)')
+        plt.ylabel(r'Beam Size Squared ($10^6 \ \mu$m$^2$)')
+        plt.legend(framealpha=0.3, loc='upper right', fontsize=14)
+
+        if save_plots:
+            plt.tight_layout()
+            import datetime
+            timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+            plt.savefig(f"infl_fit_{timestamp}.png", dpi=300)
         plt.show()
         plt.close()
 
     return left, right
 
+def add_measurements_btwn_pnts(x, y, y_err, num_points, axis, bs_fn):
+    """ This function adds measurements to a dataset to reach
+    a certain number of specified measurements within some range
+    """
+
+    # Define # of points to add
+    num_meas = num_points - len(y)
+
+    if num_meas <= 0:
+        # do nothing
+        return x, y, y_err
+
+    # We want to add points primarily around min
+    # Find min location
+    argmin = np.argmin(y)
+    if argmin<(len(y)-1):
+        # if min is not at edge
+        # get first step size
+        step = (x[argmin+1]-x[argmin])/2
+        # add points to the right of min
+        mult_fac = 1
+    elif argmin==len(y)-1:
+        # if min is the last data point
+        step = (x[argmin] - x[argmin-1]) / 2
+        # add points to the left of the min
+        mult_fac = -1
+
+    x_add = []
+    # We want to add points between already measured points
+    step_mult = np.arange(1, num_meas*2, 2)
+    for i in range(0, num_meas):
+        # get quad values for points to add
+        x_add.append(x[argmin] + mult_fac*step*step_mult[i])
+
+    # Take new measurements
+    idx_size = 1 if axis == "y" else 0
+    idx_err = 3 if axis == "y" else 2
+    new_data = bs_fn(x_add)
+    y_add, y_err_add = new_data[idx_size], new_data[idx_err]
+
+    # Insert new data into original dataset
+    for i in range(0, num_meas):
+        if mult_fac == -1:
+            # add points to the left
+            new_idx = abs(argmin-i)
+            x.insert(new_idx, x_add[i])
+            y.insert(new_idx, y_add[i])
+            y_err.insert(new_idx, y_err_add[i])
+        elif mult_fac == 1:
+            # add points to the right
+            # TODO add points to both sides when min is in the middle
+            new_idx = argmin+step_mult[i]
+            x.insert(new_idx, x_add[i])
+            y.insert(new_idx, y_add[i])
+            y_err.insert(new_idx, y_err_add[i])
+
+    return x, y, y_err
+
 def func(x, a, b, c):
     """
     Second degree polynomial function of the form
@@ -287,7 +377,7 @@ def func(x, a, b, c):
     :param c: zeroth deg coeff
     :return: f(x)
     """
-    return a*x**2 + b*x + c
+    return a*x*x + b*x + c
 
 class ComplexRootError(Exception):
     """
diff --git a/pyemittance/emit_eval_example.py b/pyemittance/emit_eval_example.py
new file mode 100644
index 0000000..8762b64
--- /dev/null
+++ b/pyemittance/emit_eval_example.py
@@ -0,0 +1,195 @@
+from pyemittance.observer import Observer
+from pyemittance.data_handler import adapt_range, check_symmetry, find_inflection_pnt, add_measurements_btwn_pnts
+from pyemittance.emittance_calc import EmitCalc
+
+# Sample emittance scan function for machine and injector surrogate
+
+def eval_emit_machine(config,
+                      quad_init = [-6, -4, -2, 0],
+                      online = False,
+                      name = 'LCLS',
+                      meas_type = 'OTRS',
+                      adapt_ranges = True,
+                      num_points = 7,
+                      check_sym = True,
+                      infl_check = True,
+                      add_pnts = True,
+                      show_plots = True,
+                      use_prev_meas = True,
+                      quad_tol = 0.05,
+                      save_runs = False,
+                      calc_bmag = False):
+
+    # get initial points from the observer
+    o = Observer([], {'x': [], 'y': []}, {'x': [], 'y': []})
+    o.use_model = False
+    o.config = config
+    o.online = online
+    o.name = name
+    o.meas_type = meas_type
+    o.use_prev_meas = use_prev_meas
+    o.tolerance = quad_tol
+
+    # get initial beamsizes (rough scan)
+    bs_x_list, bs_y_list, bs_x_list_err, bs_y_list_err = o.measure_beam(quad_init)
+
+    quad_range_x = quad_init
+    quad_range_y = quad_init
+
+    if adapt_ranges:
+        quad_range_x = adapt_range(quad_range_x, bs_x_list, 'x', w=bs_x_list_err, num_points=num_points)
+        quad_range_y = adapt_range(quad_range_y, bs_y_list, 'y', w=bs_y_list_err, num_points=num_points)
+
+        new_beamsize_x = o.measure_beam(quad_range_x)
+        bs_x_list, bs_x_list_err = new_beamsize_x[0], new_beamsize_x[2]
+        new_beamsize_y = o.measure_beam(quad_range_y)
+        bs_y_list, bs_y_list_err = new_beamsize_y[1], new_beamsize_y[3]
+    else:
+        quad_range_x = quad_init
+        quad_range_y = quad_init
+
+    if check_sym:
+        add_points_x = check_symmetry(quad_range_x, bs_x_list, bs_x_list_err, 'x',
+                                      bs_fn=o.measure_beam, add_meas=True)
+        add_points_y = check_symmetry(quad_range_y, bs_y_list, bs_y_list_err, 'y',
+                                      bs_fn=o.measure_beam, add_meas=True)
+
+        if add_points_x is not None:
+            quad_range_x = add_points_x[0]
+            bs_x_list = add_points_x[1]
+            bs_x_list_err = add_points_x[2]
+
+        if add_points_y is not None:
+            quad_range_y = add_points_y[0]
+            bs_y_list = add_points_y[1]
+            bs_y_list_err = add_points_y[2]
+
+    if infl_check:
+        left_x, right_x = find_inflection_pnt(quad_range_x, bs_x_list, show_plots=show_plots)
+        left_y, right_y = find_inflection_pnt(quad_range_y, bs_y_list, show_plots=show_plots)
+
+        # truncate data
+        quad_range_x = quad_range_x[left_x:right_x]
+        bs_x_list = bs_x_list[left_x:right_x]
+        bs_x_list_err = bs_x_list_err[left_x:right_x]
+
+        quad_range_y = quad_range_y[left_y:right_y]
+        bs_y_list = bs_y_list[left_y:right_y]
+        bs_y_list_err = bs_y_list_err[left_y:right_y]
+
+    if add_pnts:
+        quad_range_x, bs_x_list, bs_x_list_err = add_measurements_btwn_pnts(quad_range_x, bs_x_list, bs_x_list_err,
+                                                                        num_points, 'x', bs_fn=o.measure_beam)
+        quad_range_y, bs_y_list, bs_y_list_err = add_measurements_btwn_pnts(quad_range_y, bs_y_list, bs_y_list_err,
+                                                                        num_points, 'y', bs_fn=o.measure_beam)
+
+    # finally get emittance
+    ef = EmitCalc({'x': quad_range_x, 'y': quad_range_y},
+                  {'x': bs_x_list, 'y': bs_y_list},
+                  {'x': bs_x_list_err, 'y': bs_y_list_err}
+                  )
+    ef.plot = show_plots
+    ef.save_runs = save_runs
+    ef.calc_bmag = calc_bmag
+
+    # get normalized transverse emittance
+    ef.get_emit()
+
+    # save total number of points queried
+    ef.out_dict["total_points_measured"] = len(o.quad_meas)
+
+    return ef.out_dict
+
+def eval_emit_surrogate(get_bs_model,
+                        config,
+                        quad_init = [-6, -4, -2, 0],
+                        adapt_ranges = True,
+                        num_points = 7,
+                        check_sym = True,
+                        infl_check = True,
+                        add_pnts = True,
+                        show_plots = False,
+                        add_noise = False,
+                        use_prev_meas = False,
+                        quad_tol = 0.05,
+                        save_runs= False,
+                        calc_bmag = False):
+
+    # get initial points from the observer
+    o = Observer([], {'x': [], 'y': []}, {'x': [], 'y': []})
+    o.use_model = True
+
+    # set beamsize fn for MODEL
+    o.get_beamsizes_model = get_bs_model
+    o.config = config
+    o.add_noise = add_noise
+    o.use_prev_meas = use_prev_meas
+    o.tolerance = quad_tol
+
+    # get initial beamsizes (rough scan)
+    bs_x_list, bs_y_list, bs_x_list_err, bs_y_list_err = o.measure_beam(quad_init)
+
+    quad_range_x = quad_init
+    quad_range_y = quad_init
+
+    if adapt_ranges:
+        quad_range_x = adapt_range(quad_range_x, bs_x_list, 'x', w=bs_x_list_err, num_points=num_points)
+        quad_range_y = adapt_range(quad_range_y, bs_y_list, 'y', w=bs_y_list_err, num_points=num_points)
+
+        new_beamsize_x = o.measure_beam(quad_range_x)
+        bs_x_list, bs_x_list_err = new_beamsize_x[0], new_beamsize_x[2]
+
+        new_beamsize_y = o.measure_beam(quad_range_y)
+        bs_y_list, bs_y_list_err = new_beamsize_y[1], new_beamsize_y[3]
+
+    if check_sym:
+        add_points_x = check_symmetry(quad_range_x, bs_x_list, bs_x_list_err, 'x',
+                                      bs_fn=o.measure_beam, add_meas=True)
+        add_points_y = check_symmetry(quad_range_y, bs_y_list, bs_y_list_err, 'y',
+                                      bs_fn=o.measure_beam, add_meas=True)
+
+        if add_points_x is not None:
+            quad_range_x = add_points_x[0]
+            bs_x_list = add_points_x[1]
+            bs_x_list_err = add_points_x[2]
+
+        if add_points_y is not None:
+            quad_range_y = add_points_y[0]
+            bs_y_list = add_points_y[1]
+            bs_y_list_err = add_points_y[2]
+
+    if infl_check:
+        left_x, right_x = find_inflection_pnt(quad_range_x, bs_x_list, show_plots=show_plots)
+        left_y, right_y = find_inflection_pnt(quad_range_y, bs_y_list, show_plots=show_plots)
+
+        # truncate data
+        quad_range_x = quad_range_x[left_x:right_x]
+        bs_x_list = bs_x_list[left_x:right_x]
+        bs_x_list_err = bs_x_list_err[left_x:right_x]
+
+        quad_range_y = quad_range_y[left_y:right_y]
+        bs_y_list = bs_y_list[left_y:right_y]
+        bs_y_list_err = bs_y_list_err[left_y:right_y]
+
+    if add_pnts:
+        quad_range_x, bs_x_list, bs_x_list_err = add_measurements_btwn_pnts(quad_range_x, bs_x_list, bs_x_list_err,
+                                                                        num_points, 'x', bs_fn=o.measure_beam)
+        quad_range_y, bs_y_list, bs_y_list_err = add_measurements_btwn_pnts(quad_range_y, bs_y_list, bs_y_list_err,
+                                                                        num_points, 'y', bs_fn=o.measure_beam)
+
+    # finally get emittance
+    ef = EmitCalc({'x': quad_range_x, 'y': quad_range_y},
+                  {'x': bs_x_list, 'y': bs_y_list},
+                  {'x': bs_x_list_err, 'y': bs_y_list_err}
+                  )
+    ef.plot = show_plots
+    ef.save_runs = save_runs
+    ef.calc_bmag = calc_bmag
+
+    # get normalized transverse emittance
+    ef.get_emit()
+
+    # save total number of points queried
+    ef.out_dict["total_points_measured"] = len(o.quad_meas)
+
+    return ef.out_dict
\ No newline at end of file
diff --git a/pyemittance/emittance_calc.py b/pyemittance/emittance_calc.py
index 65606c0..68f9fd7 100644
--- a/pyemittance/emittance_calc.py
+++ b/pyemittance/emittance_calc.py
@@ -1,41 +1,53 @@
 import numpy as np
-import matplotlib.pyplot as plt
 from pyemittance.optics import estimate_sigma_mat_thick_quad, twiss_and_bmag, get_kL, normalize_emit
-from pyemittance.beam_io import get_twiss0
+from pyemittance.machine_settings import get_twiss0
+from pyemittance.saving_io import save_emit_run
 
 class EmitCalc:
     """
     Uses info recorded in Observer to do an emittance fit
     """
-
     def __init__(self, quad_vals=None, beam_vals=None, beam_vals_err=None):
         self.quad_vals = {'x': np.empty(0, ), 'y': np.empty(0, )} if quad_vals is None else quad_vals # in kG
         self.beam_vals = {'x': np.empty(0, ), 'y': np.empty(0, )} if beam_vals is None else beam_vals
-        self.beam_vals_err = {'x': np.empty(0, ), 'y': np.empty(0, )} if beam_vals_err is None else beam_vals_err
-        self.x_use = np.arange(0, len(self.beam_vals['x']), 1)
-        self.y_use = np.arange(0, len(self.beam_vals['y']), 1)
 
+        # Make sure error is added to beamsizes if none is provided
+        if beam_vals_err is None or sum(beam_vals_err['x'])==0 or sum(beam_vals_err['y'])==0:
+            self.bs_error = (0.015, 0.015) # Define some error on beamsizes in each dimension
+            self.beam_vals_err = {'x': np.asarray(self.beam_vals['x'])*self.bs_error[0],
+                                  'y': np.asarray(self.beam_vals['y'])*self.bs_error[1]}
+        else:
+            self.beam_vals_err = beam_vals_err
+
+        self.dims = ['x', 'y'] # TODO: make code use provided in self.dims instead of hardcoding 'x' and 'y'
         self.sig_mat_screen = {'x': [], 'y': []}
         self.twiss0 = get_twiss0() # emit, beta, alpha
         self.twiss_screen = {'x': [], 'y': []} # emit, beta, alpha
         self.beta_err = None
         self.alpha_err = None
 
-        self.test_mode = False
-        self.noise_red = 50000
-        self.plot = True
         self.calc_bmag = False
-
-    def check_conditions(self, ):
-
-        self.x_use = np.arange(0, len(beam_vals['x']), 1)
-        self.y_use = np.arange(0, len(beam_vals['y']), 1)
-
-        minx = np.min(self.beam_vals['x'])
-        miny = np.min(self.beam_vals['y'])
-
-        self.x_use = np.argwhere(self.beam_vals['x'] < 2.0 * minx)
-        self.y_use = np.argwhere(self.beam_vals['y'] < 2.0 * miny)
+        self.plot = False
+        self.verbose = False
+        self.save_runs = False
+
+        # Main output of emittance calc
+        self.out_dict = {'nemitx': None,
+                         'nemity': None,
+                         'nemitx_err': None,
+                         'nemity_err': None,
+                         'nemit': None,
+                         'nemit_err': None,
+                         'bmagx': None,
+                         'bmagy': None,
+                         'bmagx_err': None,
+                         'bmagy_err': None,
+                         'opt_q_x': None,
+                         'opt_q_y': None,
+                         'total_points_measured': None,
+                         'bmag_emit': None,
+                         'bmag_emit_err': None
+                         }
 
     def weighting_func(self, beamsizes, beamsizes_err):
         """
@@ -60,60 +72,73 @@ def error_propagation(self, gradient):
         """
         return np.sqrt( (gradient.T @ self.covariance_matrix) @ gradient)
 
-    def get_emit(self, dim='x'):
+    def get_emit(self):
         """
         Get emittance at quad from beamsizes and quad scan
         :param dim: 'x' or 'y'
         :return: normalized emittance and error
         """
 
-        q = self.quad_vals[dim]
-        # quad vals are passed in machine units
-        kL = get_kL(q)
+        for dim in self.dims:
+            # run emit calc for x and y
 
-        bs = self.beam_vals[dim]
-        bs_err = self.beam_vals_err[dim]
-        
+            q = self.quad_vals[dim]
+            # quad vals are passed in machine units
+            kL = get_kL(q)
 
-        weights = self.weighting_func(bs, bs_err) # 1/sigma
+            bs = self.beam_vals[dim]
+            bs_err = self.beam_vals_err[dim]
 
-        if self.test_mode == False:
-            res = estimate_sigma_mat_thick_quad(bs, kL, bs_err, weights, 
-                                                calc_bmag=self.calc_bmag, plot=self.plot)
-            if np.isnan(res[0]):
-                return np.nan, np.nan, np.nan, np.nan
-            else:
-                emit, emit_err, beta_rel_err, alpha_rel_err = res[0:4]
-                if self.calc_bmag:
-                    sig_11, sig_12, sig_22 = res[4:]
+            weights = self.weighting_func(bs, bs_err) # 1/sigma
 
-        if self.test_mode == True:
-            bs = bs + np.random.rand(len(bs)) / self.noise_red
-            print("NOISE")
-            res = estimate_sigma_mat_thick_quad(bs, kL, bs_err, weights, 
-                                                calc_bmag=self.calc_bmag, plot=self.plot)
+            # Storing quadvals and beamsizes in self.out_dict for plotting purposes
+            self.out_dict[f'quadvals{dim}'] = list(q)
+            self.out_dict[f'beamsizes{dim}'] = list(bs)
+            self.out_dict[f'beamsizeserr{dim}'] =  list(bs_err)
+
+            res = estimate_sigma_mat_thick_quad(bs, kL, bs_err, weights, dim=dim,
+                                                calc_bmag=self.calc_bmag,
+                                                plot=self.plot, verbose=self.verbose)
             if np.isnan(res[0]):
-                return np.nan, np.nan, np.nan, np.nan
+                self.out_dict['nemitx'], self.out_dict['nemity'] = np.nan, np.nan
+                self.out_dict['nemitx_err'], self.out_dict['nemity_err'] = np.nan, np.nan
+                self.out_dict['bmagx'], self.out_dict['bmagy'] = np.nan, np.nan
+                self.out_dict['bmagx_err'], self.out_dict['bmagy_err'] = np.nan, np.nan
+                return self.out_dict
             else:
                 emit, emit_err, beta_rel_err, alpha_rel_err = res[0:4]
                 if self.calc_bmag:
                     sig_11, sig_12, sig_22 = res[4:]
 
-        emit, emit_err = normalize_emit(emit, emit_err)
+            norm_emit_res = normalize_emit(emit, emit_err)
+            self.out_dict[f'nemit{dim}'] = normalize_emit(emit, emit_err)[0]
+            self.out_dict[f'nemit{dim}_err'] = normalize_emit(emit, emit_err)[1]
+
+            if self.calc_bmag:
+                self.sig_mat_screen[dim] = [sig_11, sig_12, sig_22]
+                self.beta_err = beta_rel_err
+                self.alpha_err = alpha_rel_err
 
-        if self.calc_bmag:
-            self.sig_mat_screen[dim] = [sig_11, sig_12, sig_22]
-            self.beta_err = beta_rel_err
-            self.alpha_err = alpha_rel_err
+                bmag_calc_res = self.get_twiss_bmag(dim=dim)
+                # Get bmag and bmag_err
+                self.out_dict[f'bmag{dim}'] = bmag_calc_res[0]
+                self.out_dict[f'bmag{dim}_err'] = bmag_calc_res[1]
+                # Get best value for scanning quad
+                self.out_dict[f'opt_q_{dim}'] = q[bmag_calc_res[2]]
 
-            bmag, bmag_err = self.get_twiss_bmag(dim=dim)
-            return emit, emit_err, min(bmag), bmag_err[np.argmin(bmag)], q[np.argmin(bmag)]
+        # get geometric mean (set to None when x and y are not calculated)
+        self.get_gmean_emit()
 
-        return emit, emit_err
+        if self.save_runs:
+            self.save_run()
+
+        return self.out_dict
 
     def get_twiss_bmag(self, dim='x'):
 
-        sig_11, sig_12, sig_22 = self.sig_mat_screen[dim][0], self.sig_mat_screen[dim][1], self.sig_mat_screen[dim][2]
+        sig_11 = self.sig_mat_screen[dim][0]
+        sig_12 = self.sig_mat_screen[dim][1]
+        sig_22 = self.sig_mat_screen[dim][2]
 
         # twiss0 in x or y AT THE SCREEN
         beta0, alpha0 = self.twiss0[dim][1], self.twiss0[dim][2]
@@ -125,7 +150,33 @@ def get_twiss_bmag(self, dim='x'):
         # Save twiss at screen
         self.twiss_screen[dim] = twiss['emit'], twiss['beta'], twiss['alpha']
 
-        return twiss['bmag'], twiss['bmag_err']
+        return twiss['bmag'], twiss['bmag_err'], twiss['min_idx']
+
+    def get_gmean_emit(self):
+
+        try:
+            nemit = np.sqrt( self.out_dict['nemitx'] * self.out_dict['nemity'] )
+            nemit_err = nemit * ( (self.out_dict['nemitx_err']/self.out_dict['nemitx'])**2 +
+                                  (self.out_dict['nemity_err']/self.out_dict['nemity'])**2 )**0.5
+
+            self.out_dict['nemit'] = nemit
+            self.out_dict['nemit_err'] = nemit_err
 
+            if self.out_dict['bmagx'] is not None and self.out_dict['bmagy'] is not None:
+                nbmag = np.sqrt( self.out_dict['bmagx'] * self.out_dict['bmagy'] )
+                bmag_emit_err = nemit*nbmag * (
+                    (self.out_dict['nemitx_err']/self.out_dict['nemitx'])**2 +
+                    (self.out_dict['nemity_err']/self.out_dict['nemity'])**2 +
+                    (self.out_dict['bmagx_err']/self.out_dict['bmagx'])**2 +
+                    (self.out_dict['bmagy_err']/self.out_dict['bmagy'])**2)**0.5
+                self.out_dict['bmag_emit'] = nemit * nbmag
+                self.out_dict['bmag_emit_err'] = bmag_emit_err
 
+        except TypeError:
+            self.out_dict['nemit'] = np.nan
+            self.out_dict['nemit_err'] = np.nan
+            self.out_dict['bmag_emit'] = np.nan
+            self.out_dict['bmag_emit_err'] = np.nan
 
+    def save_run(self):
+        save_emit_run(self.out_dict)
\ No newline at end of file
diff --git a/pyemittance/image.py b/pyemittance/image.py
index 25d42b9..8da1156 100644
--- a/pyemittance/image.py
+++ b/pyemittance/image.py
@@ -67,8 +67,8 @@ def get_im_projection(self, subtract_baseline=True):
         if subtract_baseline:
             self.x_proj = self.x_proj - np.mean(self.x_proj[0:self.offset])
             self.y_proj = self.y_proj - np.mean(self.y_proj[0:self.offset])
-        #self.x_proj = np.clip(self.x_proj, -500, np.inf)
-        #self.y_proj = np.clip(self.y_proj, 800, np.inf)
+        # self.x_proj = np.clip(self.x_proj, 90, np.inf)
+        # self.y_proj = np.clip(self.y_proj, 90, np.inf)
         return self.x_proj, self.y_proj    
             
     def dispatch(self, name, *args, **kwargs):
@@ -78,7 +78,7 @@ def dispatch(self, name, *args, **kwargs):
             }
         return fit_type_dict[name](*args, **kwargs)
 
-    def get_sizes(self, method = "gaussian", show_plots = False, cut_area = 0.05):
+    def get_sizes(self, method = "gaussian", show_plots = True, cut_area = 0.05):
         """Takes an image (2D array) and optional bg image, finds x and y projections,
         and fits with desired method. Current options are "gaussian" or "rms cut area".
         Returns size in x, size in y, error on x size, error on  y size"""
diff --git a/pyemittance/machine_settings.py b/pyemittance/machine_settings.py
new file mode 100644
index 0000000..415eb44
--- /dev/null
+++ b/pyemittance/machine_settings.py
@@ -0,0 +1,77 @@
+# This file contains functions to retrieve  settings for the machine
+# (r-matrices, Twiss params, etc)
+# These should be specified here or in json config files
+import os
+import numpy as np
+import json
+
+### '''''CHANGE HERE ''' #TODO: update config settings
+meas_type = 'OTRS'
+#################
+
+if meas_type == 'WIRE':
+    add_path = '/LCLS_WS02'
+elif meas_type == 'OTRS':
+    add_path = '/LCLS2_OTR3'
+else:
+    add_path = ''
+
+this_dir, this_filename = os.path.split(__file__)
+CONFIG_PATH = os.path.join(this_dir, 'configs' + add_path)
+
+def which_machine(filepath=CONFIG_PATH+'/beamline_info.json'):
+    """Print which machine settings are being used"""
+    beamline_info = json.load(open(filepath))
+    name = beamline_info['name']
+    print(f"Using {name} beamline info.")
+
+def get_twiss0(filepath= CONFIG_PATH+'/beamline_info.json'):
+    """Import Twiss0 from config file"""
+
+    beamline_info = json.load(open(filepath))
+    twiss0 = beamline_info['Twiss0']
+    # emit, beta, alpha
+    twiss0_by_dim = {'x': [twiss0[0], twiss0[2], twiss0[4]],
+                     'y': [twiss0[1], twiss0[3], twiss0[5]]
+                     }
+
+    return twiss0_by_dim
+
+def get_rmat(filepath=CONFIG_PATH+'/beamline_info.json'):
+    """Import r-matrix from config file"""
+
+    beamline_info = json.load(open(filepath))
+    # if only separated by a drift:
+    # rMat will be [1, L, 0, 1]
+
+    # try:
+    rmatx = beamline_info['rMatx']
+    rmaty = beamline_info['rMaty']
+    # m11, m12, m21, m22
+    rmatx_array = np.array([[rmatx[0], rmatx[1]],
+                            [rmatx[2], rmatx[3]]
+                           ])
+    rmaty_array = np.array([[rmaty[0], rmaty[1]],
+                        [rmaty[2], rmaty[3]]
+                       ])
+
+    return rmatx_array, rmaty_array
+    # except KeyError:
+    #     # TODO: dumb hack for old json 
+    #     rmat = beamline_info['rMat']
+    #     rmat = [np.array([[rmat[0], rmat[1]],[rmat[2], rmat[3]]]), np.array([[rmat[0], rmat[1]],[rmat[2], rmat[3]]])]
+    #     return rmat
+
+def get_energy(filepath=CONFIG_PATH+'/beamline_info.json'):
+    """Import beam energy from config file [GeV]"""
+
+    beamline_info = json.load(open(filepath))
+    energy = beamline_info['energy']
+    return energy
+
+def get_quad_len(filepath=CONFIG_PATH+'/beamline_info.json'):
+    """Import quad len from config file [m]"""
+
+    beamline_info = json.load(open(filepath))
+    l = beamline_info['l']
+    return l
\ No newline at end of file
diff --git a/pyemittance/observer.py b/pyemittance/observer.py
index 8fc0107..930646c 100644
--- a/pyemittance/observer.py
+++ b/pyemittance/observer.py
@@ -1,6 +1,5 @@
-import numpy as np
 import bisect
-from pyemittance.beam_io import get_beamsizes_machine
+import numpy as np
 
 class Observer:
     """
@@ -12,79 +11,87 @@ def __init__(self, quad_meas, beam_meas, beam_meas_err):
         self.quad_meas = quad_meas
         self.beam_meas = beam_meas
         self.beam_meas_err = beam_meas_err
-        self.use_prev_meas = True 
+        self.use_prev_meas = False
         self.tolerance = 0.1
-        
-        # if using the surrogate model
+
+        self.config = None
         self.use_model = True
+        # if using the surrogate model
         self.get_beamsizes_model = None
-        self.config = None
+        self.add_noise = False
+        self.noise_red = 100000
         
         # if using machine
         self.use_profmon = False
+        self.online = False
+        self.name = 'sim'
+        self.meas_type = 'OTRS'
 
     def measure_beam(self, quad_list):
         xrms = []
         yrms = []
         xrms_err = []
         yrms_err = []
-                
-        if not self.quad_meas:
-                # if no measurements exist yet, measure all
-                for val in quad_list:
-                    # measure bs at this value
-                    beamsizes = self.get_beamsizes(val)
-                    xrms.append(beamsizes[0])
-                    yrms.append(beamsizes[1])
-                    xrms_err.append(beamsizes[2])
-                    yrms_err.append(beamsizes[3])
-
-                    # update saved values
-                    self.quad_meas.append(val)
-                    self.beam_meas['x'] = xrms
-                    self.beam_meas['y'] = yrms
-                    self.beam_meas_err['x'] = xrms_err
-                    self.beam_meas_err['y']= yrms_err
+
+        if not self.quad_meas or self.use_prev_meas is False:
+            # if no measurements exist yet, measure all
+            for val in quad_list:
+                # measure bs at this value
+                beamsizes = self.get_beamsizes(val)
+                xrms.append(beamsizes[0])
+                yrms.append(beamsizes[1])
+                xrms_err.append(beamsizes[2])
+                yrms_err.append(beamsizes[3])
+
+                # update saved values
+                self.quad_meas.append(val)
+                self.beam_meas['x'].append(xrms[-1])
+                self.beam_meas['y'].append(yrms[-1])
+                self.beam_meas_err['x'].append(xrms_err[-1])
+                self.beam_meas_err['y'].append(yrms_err[-1])
                 
         else:
-            for val in quad_list:              
+            for val in quad_list:
                 # find loc within sorted list
                 loc = bisect.bisect_left(self.quad_meas, val)
 
-                if (loc != 0 and 
-                    loc != len(self.quad_meas)-1 and 
-                    loc != len(self.quad_meas)
-                   ):
-                    
+                if (loc != 0 and loc != len(self.quad_meas)-1 and loc < len(self.quad_meas)):
                     # compare to values before and after
                     diff_prev = abs(val - self.quad_meas[loc-1])
-                    diff_next = abs(self.quad_meas[loc] - val) 
+                    diff_next = abs(self.quad_meas[loc] - val)
+                elif loc == 0:
+                    diff_prev = np.inf
+                    diff_next = abs(self.quad_meas[loc] - val)
+                elif loc == len(self.quad_meas)-1:
+                    diff_prev = abs(val - self.quad_meas[loc-1])
+                    diff_next = abs(self.quad_meas[loc] - val)
+                elif loc >= len(self.quad_meas):
+                    diff_prev = abs(val - self.quad_meas[-1])
+                    diff_next = np.inf
 
-                if (loc == 0 or 
-                    loc == len(self.quad_meas)-1 or 
-                    loc == len(self.quad_meas) or
-                    (diff_prev > self.tolerance and diff_next > self.tolerance)
-                   ):
+                if diff_prev > self.tolerance and diff_next > self.tolerance or loc >= len(self.quad_meas):
+                    # if no neighboring value is within tol
+                    # or if value has not been measured
                     
                     # add in list and measure value
-                    self.quad_meas[loc:loc] = [val]
+                    self.quad_meas.insert(loc, val)
 
                     # measure bs at this value
                     # returns xrms, yrms, xrms_err, yrms_err
                     beamsizes = self.get_beamsizes(val)
 
                     # add new quad value in same location
-                    self.beam_meas['x'][loc:loc] = [beamsizes[0]]
-                    self.beam_meas['y'][loc:loc] = [beamsizes[1]]
-                    self.beam_meas_err['x'][loc:loc] = [beamsizes[2]]
-                    self.beam_meas_err['y'][loc:loc] = [beamsizes[3]]
+                    self.beam_meas['x'].insert(loc, beamsizes[0])
+                    self.beam_meas['y'].insert(loc, beamsizes[1])
+                    self.beam_meas_err['x'].insert(loc, beamsizes[2])
+                    self.beam_meas_err['y'].insert(loc, beamsizes[3])
 
                     xrms.append(self.beam_meas['x'][loc])
                     yrms.append(self.beam_meas['y'][loc])
                     xrms_err.append(self.beam_meas_err['x'][loc])
                     yrms_err.append(self.beam_meas_err['y'][loc])
 
-                else: # if either is <= tolerance 
+                else: # if either is <= tolerance
                     if diff_prev <= diff_next:
                         use_loc = loc-1
                     else:
@@ -95,15 +102,33 @@ def measure_beam(self, quad_list):
                     yrms.append(self.beam_meas['y'][use_loc])
                     xrms_err.append(self.beam_meas_err['x'][use_loc])
                     yrms_err.append(self.beam_meas_err['y'][use_loc])
-                
+
         return xrms, yrms, xrms_err, yrms_err
-                                    
-        
+
     def get_beamsizes(self, val):
         """Define where the beamsizes are acquired from"""
-        if self.use_model == True:
+        if self.use_model:
+            if self.add_noise:
+                # this is outdated/not used right now
+                beamsizes = self.get_beamsizes_model(self.config, val)
+                xrms = beamsizes[0] + np.random.rand(1) / self.noise_red
+                yrms = beamsizes[1] + np.random.rand(1) / self.noise_red
+                xrms_err = beamsizes[2] + np.random.rand(1) / self.noise_red / 10
+                yrms_err = beamsizes[3] + np.random.rand(1) / self.noise_red / 10
+                return xrms[0], yrms[0], xrms_err[0], yrms_err[0]
+
+            if len(np.asarray(self.config).shape) == 2:
+                # temp workaround for testing
+                out = self.get_beamsizes_model(self.config[0]+[val])
+                return np.array([out["sigma_x"][0], out["sigma_y"][0], 0., 0.])
+
             return self.get_beamsizes_model(self.config, val)
 
-        if self.use_model == False:
-            return get_beamsizes_machine(val, self.use_profmon)
+        else:
+            from pyemittance.beam_io import MachineIO
+            io = MachineIO(self.name, self.meas_type)
+            io.online = self.online
+            io.use_profmon = self.use_profmon
+            # note we are not setting the injector on the machine here
+            return io.get_beamsizes_machine(self.config, val)
         
diff --git a/pyemittance/optics.py b/pyemittance/optics.py
index 9a56f1a..fd75526 100644
--- a/pyemittance/optics.py
+++ b/pyemittance/optics.py
@@ -1,13 +1,16 @@
 # Module containing functions for beam optics calculations
 import numpy as np
+import os, json
 from numpy import sin, cos, sinh, cosh, sqrt
 import scipy.linalg
 # TODO update fns
 from scipy.constants import c as c_light, m_e as m0
 import matplotlib.pyplot as plt
-from pyemittance.beam_io import get_rmat
 
-def get_gradient(b_field, l_eff=0.108):
+from pyemittance.machine_settings import get_rmat, which_machine, get_energy, get_quad_len
+
+
+def get_gradient(b_field, l_eff=get_quad_len()):
     """
     Calculates quadrupole gradient from B field.
 
@@ -25,7 +28,7 @@ def get_gradient(b_field, l_eff=0.108):
     """
     return np.array(b_field) * 0.1 / l_eff
 
-def get_k1(g, energy=0.135, m_0=0.000511):
+def get_k1(g, energy=get_energy(), m_0=0.000511):
     """
     Calculates quadrupole strength from gradient.
 
@@ -51,16 +54,16 @@ def get_k1(g, energy=0.135, m_0=0.000511):
     beta = np.sqrt(1 - 1 / gamma ** 2)
     return 0.2998 * g / energy / beta
 
-def normalize_emit(emit, err, energy=0.135, m_0=0.000511):
+def normalize_emit(emit, err, energy=get_energy(), m_0=0.000511):
     gamma = energy / m_0
     beta = np.sqrt(1 - 1 / gamma ** 2)
     return emit*gamma*beta, err*gamma*beta
 
-def get_kL(quad_vals, l=0.108, energy=0.135, m_0=0.000511):
-    kL = get_k1(get_gradient(quad_vals), energy=energy, m_0=m_0) * l
+def get_kL(quad_vals, l=get_quad_len(), energy=get_energy(), m_0=0.000511):
+    kL = get_k1(get_gradient(quad_vals), energy, m_0=m_0) * l
     return kL
 
-def get_quad_field(k, energy=0.135, l=0.108, m_0=0.000511):
+def get_quad_field(k, energy=get_energy(), l=get_quad_len(), m_0=0.000511):
     """Get quad field [kG] from k1 [1/m^2]"""
 
     gamma = energy / m_0
@@ -75,16 +78,21 @@ def thin_quad_mat2(kL):
     """
     return np.array([[1, 0], [-kL, 1]])
 
-def r_mat2():
+def r_mat2(dim, d=None):
     """
     Transport matrix after quad to screen, 2x2
     """
-    return get_rmat()
+    if d is not None:
+        # return drift mat
+        return np.array([[1, d],[0, 1]])
+    # if other elements are there
+    return get_rmat()[0] if dim=='x' else get_rmat()[1]
 
-def quad_mat2(kL, L=0):
+def quad_mat2(kL, L=0, d=None):
     """
     Quadrupole transfer matrix, 2x2, assuming some quad thickness
     L = 0 returns thin quad matrix
+    d not None get drift mat 
     :param kL: quad strength * quad length (1/m)
     :param L: quad length (m)
     :return: thick quad transport matrix
@@ -96,7 +104,8 @@ def quad_mat2(kL, L=0):
     k = kL / L
 
     if k == 0:
-        mat2 = r_mat2()
+        # Take drift or custom mat
+        mat2 = r_mat2(dim, d=d)
     elif k > 0:
         # Focusing
         rk = sqrt(k)
@@ -110,7 +119,7 @@ def quad_mat2(kL, L=0):
 
     return mat2
 
-def quad_rmat_mat2(kL, Lquad=0):
+def quad_rmat_mat2(kL, dim, d=None, Lquad=0):
     """
     Composite [quad, drift] 2x2 transfer matrix
     :param kL: quad strength * quad length (1/m)
@@ -118,7 +127,11 @@ def quad_rmat_mat2(kL, Lquad=0):
     :return:
     """
 
-    return r_mat2() @ quad_mat2(kL, Lquad)
+    if kL == 0:
+        # Return matrix after quad to screen
+        return r_mat2(dim, d)
+
+    return r_mat2(dim, d) @ quad_mat2(kL, Lquad, d=d)
 
 def propagate_sigma(mat2_init, mat2_ele):
     """
@@ -129,7 +142,8 @@ def propagate_sigma(mat2_init, mat2_ele):
     """
     return (mat2_ele @ mat2_init) @ mat2_ele.T
 
-def estimate_sigma_mat_thick_quad(sizes, kLlist, sizes_err=None, weights=None, Lquad=0.108, calc_bmag=False, plot=True):
+def estimate_sigma_mat_thick_quad(sizes, kLlist, sizes_err=None, weights=None, dim='x', Lquad=get_quad_len(),
+                                  calc_bmag=False, plot=True, verbose=False):
     """
     Estimates the beam sigma matrix at a screen by scanning an upstream quad.
     This models the system as a thick quad.
@@ -140,8 +154,11 @@ def estimate_sigma_mat_thick_quad(sizes, kLlist, sizes_err=None, weights=None, L
     :param plot: bool to plot ot not
     :return: emittance, sig11, sig12 and sig22 at measurement screen
     """
+    if verbose:
+        # Print which machine settings it is using
+        which_machine()
 
-    # measurement vector
+    # Measurement vector
     sizes = np.array(sizes)
     if np.isnan(sizes).any():
         idx_not_nan = ~np.isnan(sizes)
@@ -153,7 +170,8 @@ def estimate_sigma_mat_thick_quad(sizes, kLlist, sizes_err=None, weights=None, L
             weights = weights[idx_not_nan]
         
     if len(sizes) < 3:
-        print("Less than 3 data points were passed. Returning NaN.")
+        if verbose:
+            print("Less than 3 data points were passed. Returning NaN.")
         return [np.nan,np.nan,np.nan,np.nan]
         
     b = sizes ** 2
@@ -172,7 +190,7 @@ def estimate_sigma_mat_thick_quad(sizes, kLlist, sizes_err=None, weights=None, L
     # Collect mat2 for later
     mat2s = []
     for kL, weight in zip(kLlist, weights):
-        mat2 = quad_rmat_mat2(kL, Lquad=Lquad)
+        mat2 = quad_rmat_mat2(kL, dim, Lquad=Lquad)
         mat2s.append(mat2)
         r11, r12, r21, r22 = mat2.flatten()
         r_mat_factor = np.array([r11 ** 2, 2 * r11 * r12, r12 ** 2])
@@ -188,7 +206,8 @@ def estimate_sigma_mat_thick_quad(sizes, kLlist, sizes_err=None, weights=None, L
 
     #return NaN if emit can't be calculated
     if emit2 < 0:
-        print("Emittance can't be computed. Returning NaN.")
+        if verbose:
+            print("Emittance can't be computed. Returning NaN.")
         #plt.plot(kLlist, sizes**2)
         return [np.nan,np.nan,np.nan,np.nan]
 
@@ -206,7 +225,8 @@ def estimate_sigma_mat_thick_quad(sizes, kLlist, sizes_err=None, weights=None, L
 
     return [emit, emit_err, beta_err/beta, alpha_err/alpha]
 
-def propagate_to_screen(s11, s12, s22, kLlist, mat2s, Lquad, sizes, sizes_err, emit, plot):
+def propagate_to_screen(s11, s12, s22, kLlist, mat2s, Lquad, sizes, sizes_err,
+                        emit, plot, save_plot=False):
     # Matrix form for propagation
     sigma0 = np.array([[s11, s12], [s12, s22]])
 
@@ -225,15 +245,24 @@ def propagate_to_screen(s11, s12, s22, kLlist, mat2s, Lquad, sizes, sizes_err, e
 
     if plot:
         # Plot the data
+        #plt.figure(figsize=(5.5,3.5))
+        #plt.figure(figsize=(5,3.5))
+
         quad = get_quad_field(kLlist / Lquad)
-        plt.errorbar(quad, sizes, yerr=sizes_err, fmt='o', label=f'Measurements')
+        plt.errorbar(quad, np.asarray(sizes)/1e-6, yerr=np.asarray(sizes_err)/1e-6, fmt='o', label=f'Measurements')
 
         # Model prediction
-        plt.errorbar(quad, np.sqrt(s11_screen), marker='.', label=f'Model')
+        plt.errorbar(quad, np.sqrt(s11_screen)/1e-6, marker='.', label=f'Model')
+
+        plt.xlabel('Quadrupole Strength (kG)')
+        plt.ylabel(r'Beam Size ($\mu$m)')
+        plt.legend(fontsize=14)
 
-        plt.xlabel('B (kG)')
-        plt.ylabel(f'sizes (m)')
-        plt.legend()
+        if save_plot:
+            import datetime
+            plt.tight_layout()
+            timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+            plt.savefig(f"emit_fit_{timestamp}.png", dpi=300)
         plt.show()
         plt.close()
 
@@ -257,12 +286,18 @@ def twiss_and_bmag(sig11, sig12, sig22, beta_err, alpha_err, beta0=1, alpha0=0):
     # Taking relative error as measured at quad
     bmag_err = bmag * np.sqrt( (beta_err)**2 + (alpha_err)**2 )
 
+    # TODO: make this take bmag at the nominal Q5 value and not the min to match Matlab
+    # what to do if nominal isn't within scanned range?
+    bmag_min = min(bmag)
+    bmag_min_err = bmag_err[np.argmin(bmag)]
+
     d = {}
     d['emit'] = emit
     d['beta'] = beta
     d['alpha'] = alpha
-    d['bmag'] = bmag
-    d['bmag_err'] = bmag_err
+    d['bmag'] = bmag_min
+    d['bmag_err'] = bmag_min_err
+    d['min_idx'] = np.argmin(bmag) # best scanning quad val
 
     return d
 
diff --git a/pyemittance/otrs_io.py b/pyemittance/otrs_io.py
new file mode 100644
index 0000000..5633309
--- /dev/null
+++ b/pyemittance/otrs_io.py
@@ -0,0 +1,324 @@
+import numpy as np
+from os import path
+import json
+import time
+import datetime
+
+from epics import caget, PV
+from pyemittance.image import Image
+from pyemittance.saving_io import save_image, numpy_save, save_config
+
+
+this_dir, this_filename = path.split(__file__)
+CONFIG_PATH = path.join(this_dir, "configs/LCLS2_OTR3")
+
+# Load image processing setting info
+im_proc = json.load(open(CONFIG_PATH+'/img_proc.json'))
+
+subtract_bg = im_proc['subtract_bg']
+bg_image = im_proc['background_im']  # specify path to bg im in json file
+use_roi = im_proc['use_roi']
+roi_xmin = im_proc['roi']['xmin']
+roi_ymin = im_proc['roi']['ymin']
+roi_xmax = im_proc['roi']['xmax']
+roi_ymax = im_proc['roi']['ymax']
+avg_ims = im_proc['avg_ims']
+n_acquire = im_proc['n_to_acquire']
+amp_threshold_x = im_proc['amp_threshold']
+amp_threshold_y = im_proc['amp_threshold']
+min_sigma = im_proc['min_sigma'] # in raw units (pixels)
+max_sigma = im_proc['max_sigma']
+max_samples = im_proc['max_samples']
+
+# Measurement PVs
+meas_pv_info = json.load(open(CONFIG_PATH + '/meas_pv_info.json'))
+
+# in meters for emittance calc
+resolution = caget(meas_pv_info['diagnostic']['pv']['resolution']) *1e-6
+im_pv = PV(meas_pv_info['diagnostic']['pv']['image'])
+n_col_pv = PV(meas_pv_info['diagnostic']['pv']['ncol'])
+n_row_pv = PV(meas_pv_info['diagnostic']['pv']['nrow'])
+x_size_pv = PV(meas_pv_info['diagnostic']['pv']['profmonxsize'])
+y_size_pv = PV(meas_pv_info['diagnostic']['pv']['profmonysize'])
+
+# thresholds in meters
+min_sigma_meters = im_proc['min_sigma']*resolution
+max_sigma_meters = im_proc['max_sigma']*resolution
+
+def get_beamsizes_otrs(use_profmon):
+    """Main function imported by beam_io
+    Option to use ProfMon PVs to get beamsizes
+    Returns xrms, yrms, xrms_err, yrms_err
+    """
+    beamsize = get_beamsizes(use_profMon=use_profmon)
+    xrms = beamsize[0]
+    yrms = beamsize[1]
+    xrms_err = beamsize[2]
+    yrms_err = beamsize[3]
+    return xrms, yrms, xrms_err, yrms_err
+
+def get_beamsizes(use_profMon=False, reject_bad_beam=True,
+                  save_summary=False, post=None):
+    """ Data acquisition from OTRS
+    Option to use either ProfMon or image processing
+    Additional option to reject bad beams
+    Returns xrms, yrms, xrms_err, yrms_err
+    """
+    xrms = np.nan
+    yrms = np.nan
+    xrms_err = np.nan
+    yrms_err = np.nan
+    xamp = np.nan
+    yamp = np.nan
+    beamsizes = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
+    im = None
+
+    if reject_bad_beam:
+
+        count = 0
+
+        while xrms <= min_sigma_meters or yrms <= min_sigma_meters \
+                or xrms > max_sigma_meters or yrms > max_sigma_meters \
+                or xamp < amp_threshold_x or yamp < amp_threshold_y \
+                or xamp*amp_threshold_x<1500 or yamp*amp_threshold_y<1500 \
+                or np.isnan(np.array(beamsizes[0:6])).any():
+                
+            if count == max_samples:
+                # resample beamsize only max_samples times
+                print(f"Resampled {count-1} times, beam still out of bounds \n")
+                print(f"xrms {xrms/1e-6:.2f} um, yrms {yrms/1e-6:.2f} um (threshold: min_rms {min_sigma_meters/1e-6:.2f} um, max_rms {max_sigma_meters/1e-6:.2f} um)")
+                print(f"xamp {xamp:.2f}, yamp {yamp:.2f} (amp_thresh: {amp_threshold_x}, in json)")
+                print(f"area_x {xamp*amp_threshold_x:.1f}, area_y {yamp*amp_threshold_y:.1f} (threshold: 1500, hardcoded)\n")
+                print("Returning NaNs")
+                return np.nan, np.nan, np.nan, np.nan
+            
+            if count > 0:
+                print("Low beam intensity/noisy or beam too small/large.")
+                #print("Waiting 1 sec and repeating measurement...")
+                #time.sleep(1)
+
+            # if this fails, make sure stats is checked on profmon gui
+            if use_profMon:
+                print("using profmon")
+                beamsizes = []
+                xrms = x_size_pv.get() * 1e-6  # in meters
+                yrms = y_size_pv.get() * 1e-6  # in meters
+                # add 2% error on ProfMon measurement
+                xrms_err = xrms*0.02
+                yrms_err = yrms*0.02
+                
+                xamp, yamp = amp_threshold_x, amp_threshold_y # DOES NOT UPDATE W/PROFMON
+
+                count = count + 1
+
+            if not use_profMon:
+
+                # if post:
+                #    beamsizes = getbeamsizes_from_img(post = post)
+                #:
+                beamsizes = getbeamsizes_from_img()
+
+                xrms = beamsizes[0]
+                yrms = beamsizes[1]
+                xrms_err = beamsizes[2]
+                yrms_err = beamsizes[3]
+                xamp = beamsizes[4]
+                yamp = beamsizes[5]
+                # im = beamsizes[6]
+
+                # convert to meters
+                xrms = xrms * resolution
+                yrms = yrms * resolution
+                xrms_err = xrms_err * resolution
+                yrms_err = yrms_err * resolution
+
+            count = count + 1
+
+
+    else:
+
+        # make sure stats is checked on profmon gui
+        if use_profMon:
+            xrms, xrms_err = x_size_pv.get() * 1e-6, 0  # in meters
+            yrms, yrms_err = y_size_pv.get() * 1e-6, 0  # in meters
+            xamp, yamp = amp_threshold_x, amp_threshold_y # DOES NOT UPDATE W/PROFMON
+            #print("Using ProfMon beamsizes.")
+
+        else:
+            if post:
+                beamsizes = getbeamsizes_from_img(post=post)
+            else:
+                beamsizes = getbeamsizes_from_img()
+
+            xrms = beamsizes[0]
+            yrms = beamsizes[1]
+            xrms_err = beamsizes[2]
+            yrms_err = beamsizes[3]
+            xamp = beamsizes[4]
+            yamp = beamsizes[5]
+            # im = beamsizes[6]
+
+            # convert to meters
+            xrms = xrms * resolution
+            yrms = yrms * resolution
+            xrms_err = xrms_err * resolution
+            yrms_err = yrms_err * resolution
+
+    if save_summary:
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+        save_config(xrms, yrms, xrms_err, yrms_err, timestamp)
+        numpy_save(xrms, yrms, xrms_err, yrms_err, timestamp)
+
+    return xrms, yrms, xrms_err, yrms_err
+
+def getbeamsizes_from_img(num_images=n_acquire, avg=avg_ims,
+                          subtract_bg=subtract_bg, post=None):
+    """Returns xrms, yrms, xrms_err, yrms_err for multiple sampled images;
+    can optionally average multiple images
+    RETURNS IN RAW PIXEL UNITS-- NEED TO MULTIPLY BY RESOLUTION FOR METERS
+    """
+
+    xrms, yrms = [0] * num_images, [0] * num_images
+    xrms_err, yrms_err = [0] * num_images, [0] * num_images
+    xamp, yamp, im = [0] * num_images, [0] * num_images, [0] * num_images
+
+    if post:
+        ncol = post[0][1]
+        nrow = post[0][2]
+    else:
+        ncol, nrow = n_col_pv.get(), n_row_pv.get()
+
+    for i in range(0, num_images):
+        
+        repeat = True
+        count = 0
+
+        # retake bad images
+        while repeat:
+            meas = get_beam_image(subtract_bg, post)
+            xrms[i], yrms[i] = meas[0:2]
+            xrms_err[i], yrms_err[i] = meas[2:4]
+            xamp[i], yamp[i], im[i] = meas[4:]
+
+            # plt.imshow(im[i])
+            # plt.show()
+
+            count = count + 1
+
+            if xamp[i] >= amp_threshold_x and yamp[i] >= amp_threshold_y \
+                    and xrms[i] > min_sigma and yrms[i] > min_sigma \
+                    and xrms[i] < max_sigma and yrms[i] < max_sigma:
+                # if conditions are met, stop resampling this image
+                repeat = False
+            elif count == max_samples:
+                # if still bad after retries, return as is (reject in outer function)
+                print(f"Beam params out of bounds in image {i} out of {num_images} samples")
+                # xrms[i], yrms[i], xrms_err[i], yrms_err[i], xamp[i], yamp[
+                #     i] = np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
+                repeat = False
+
+    # average images before taking fits
+    if avg == True:
+                      
+        idx = ~np.isnan(xrms)
+        if True not in idx:
+            print(f"All {num_images} image NaNs are NaNs, trying to average images now.")
+            all_nan = True
+        else:
+            all_nan = False
+
+        im = np.mean(im, axis=0)
+
+        im = Image(im, ncol, nrow, bg_image=bg_image)
+
+        im.reshape_im()
+        if subtract_bg:
+            im.subtract_bg()
+        im.get_im_projection()
+
+        # plt.imshow(im.proc_image)
+
+        meas =  im.get_sizes(show_plots=False)
+        mean_xrms, mean_yrms = meas[0:2]
+        mean_xrms_err, mean_yrms_err = meas[2:4]
+        mean_xamp, mean_yamp = meas[4:]
+
+        if mean_xamp < amp_threshold_x or mean_yamp < amp_threshold_y \
+        or mean_xrms < min_sigma and mean_yrms < min_sigma \
+        or mean_xrms > max_sigma and mean_yrms > max_sigma:
+            if not all_nan:
+                print(f"Beam params out of bounds in averaged image")
+            else:
+                print(f"Beam params out of bounds in averaged image, initial {num_images} all NaNs")
+                #return [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
+
+        # save_beam = list(np.array(beamsizes[0:4])*resolution/1e-6)
+
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+        # pass beamsizes in um
+        save_image(im.proc_image, ncol, nrow, timestamp, avg_img=True)
+
+        return [mean_xrms, mean_yrms,
+                mean_xrms_err, mean_yrms_err,
+                mean_xamp, mean_yamp, im.proc_image]
+
+
+    # average individual rms fits
+    else:
+        idx = ~np.isnan(xrms)
+
+        if True not in idx:
+            print("All points are NaNs")
+            return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
+
+        mean_xrms = np.mean(np.array(xrms)[idx])
+        mean_yrms = np.mean(np.array(yrms)[idx])
+        mean_xrms_err = np.std(np.array(xrms)[idx]) / np.sqrt(len(idx))
+        mean_yrms_err = np.std(np.array(yrms)[idx]) / np.sqrt(len(idx))
+        mean_xamp = np.mean(np.array(xamp)[idx])
+        mean_yamp = np.mean(np.array(yamp)[idx])
+
+        im = Image(im[0], ncol, nrow, bg_image=bg_image)
+
+        im.reshape_im()
+        im.get_im_projection()
+
+        return [mean_xrms, mean_yrms,
+                mean_xrms_err, mean_yrms_err,
+                mean_xamp, mean_yamp, im.proc_image]
+
+def get_beam_image(subtract_bg=subtract_bg, post=None):
+    """Get beam image from screen
+    Return beamsize info and processed image
+    """
+
+    if post:
+        im = post[0]
+        ncol = post[1]
+        nrow = post[2]
+    else:
+        im = im_pv.get()
+        ncol, nrow = n_col_pv.get(), n_row_pv.get()
+
+    beam_image = Image(im, ncol, nrow, bg_image=bg_image)
+    beam_image.reshape_im()
+
+    if subtract_bg:
+        beam_image.subtract_bg()
+
+    if use_roi:
+        beam_image.proc_image = beam_image.proc_image[roi_ymin:roi_ymax, roi_xmin:roi_xmax]
+
+    beam_image.get_im_projection()
+
+    # fit the profile and return the beamsizes
+    beamsizes = beam_image.get_sizes(show_plots=False)
+
+    # save_beam = list(np.array(beamsizes[0:4])*resolution/1e-6)
+
+    timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+    # savesummary(beamsizes,timestamp)# pass beamsizes in um
+    save_image(im, ncol, nrow, timestamp, avg_img=False)
+    print(timestamp)
+
+    return list(beamsizes) + [beam_image.proc_image]
\ No newline at end of file
diff --git a/pyemittance/otrs_io_original.py b/pyemittance/otrs_io_original.py
new file mode 100644
index 0000000..49587a5
--- /dev/null
+++ b/pyemittance/otrs_io_original.py
@@ -0,0 +1,295 @@
+import numpy as np
+from os import path
+import json
+import time
+import datetime
+
+from epics import caget, PV
+from pyemittance.image import Image
+from pyemittance.saving_io import save_image, numpy_save, save_config
+
+
+this_dir, this_filename = path.split(__file__)
+CONFIG_PATH = path.join(this_dir, "configs/LCLS_OTR3")
+
+# Load image processing setting info
+im_proc = json.load(open(CONFIG_PATH+'/img_proc.json'))
+
+subtract_bg = im_proc['subtract_bg']
+bg_image = im_proc['background_im']  # specify path to bg im in json file
+use_roi = im_proc['use_roi']
+roi_xmin = im_proc['roi']['xmin']
+roi_ymin = im_proc['roi']['ymin']
+roi_xmax = im_proc['roi']['xmax']
+roi_ymax = im_proc['roi']['ymax']
+avg_ims = im_proc['avg_ims']
+n_acquire = im_proc['n_to_acquire']
+amp_threshold_x = im_proc['amp_threshold']
+amp_threshold_y = im_proc['amp_threshold']
+min_sigma = im_proc['min_sigma']
+max_sigma = im_proc['max_sigma']
+max_samples = im_proc['max_samples']
+
+# Measurement PVs
+meas_pv_info = json.load(open(CONFIG_PATH + '/meas_pv_info.json'))
+
+# in meters for emittance calc
+resolution = caget(meas_pv_info['diagnostic']['pv']['resolution']) *1e-6
+im_pv = PV(meas_pv_info['diagnostic']['pv']['image'])
+n_col_pv = PV(meas_pv_info['diagnostic']['pv']['ncol'])
+n_row_pv = PV(meas_pv_info['diagnostic']['pv']['nrow'])
+x_size_pv = PV(meas_pv_info['diagnostic']['pv']['profmonxsize'])
+y_size_pv = PV(meas_pv_info['diagnostic']['pv']['profmonysize'])
+
+def get_beamsizes_otrs(use_profmon):
+    """Main function imported by beam_io
+    Option to use ProfMon PVs to get beamsizes
+    Returns xrms, yrms, xrms_err, yrms_err
+    """
+    beamsize = get_beamsizes(use_profMon=use_profmon)
+    xrms = beamsize[0]
+    yrms = beamsize[1]
+    xrms_err = beamsize[2]
+    yrms_err = beamsize[3]
+    return xrms, yrms, xrms_err, yrms_err
+
+def get_beamsizes(use_profMon=False, reject_bad_beam=False,
+                  save_summary=False, post=None):
+    """ Data acquisition from OTRS
+    Option to use either ProfMon or image processing
+    Additional option to reject bad beams
+    Returns xrms, yrms, xrms_err, yrms_err
+    """
+    use_profMon = True
+
+    xrms = np.nan
+    yrms = np.nan
+    xrms_err = np.nan
+    yrms_err = np.nan
+    xamp = np.nan
+    yamp = np.nan
+    beamsizes = [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
+    im = None
+
+    if reject_bad_beam:
+
+        count = 0
+
+        while xrms <= min_sigma or yrms <= min_sigma \
+                or xrms > max_sigma or yrms > max_sigma \
+                or np.isnan(np.array(beamsizes[0:6])).any():
+
+            if count > 1:
+                print("Low beam intensity/noisy or beam too small/large.")
+                print("Waiting 1 sec and repeating measurement...")
+                time.sleep(1)
+
+            # if this fails, make sure stats is checked on profmon gui
+            if use_profMon:
+                beamsizes = []
+                xrms = x_size_pv.get() * 1e-6  # in meters
+                yrms = y_size_pv.get() * 1e-6  # in meters
+                # add 2% error on ProfMon measurement
+                xrms_err = xrms*0.02
+                yrms_err = yrms*0.02
+
+                count = count + 1
+
+            if not use_profMon:
+
+                # if post:
+                #    beamsizes = getbeamsizes_from_img(post = post)
+                #:
+                beamsizes = getbeamsizes_from_img()
+
+                xrms = beamsizes[0]
+                yrms = beamsizes[1]
+                xrms_err = beamsizes[2]
+                yrms_err = beamsizes[3]
+                xamp = beamsizes[4]
+                yamp = beamsizes[5]
+                # im = beamsizes[6]
+
+                # convert to meters
+                xrms = xrms * resolution
+                yrms = yrms * resolution
+                xrms_err = xrms_err * resolution
+                yrms_err = yrms_err * resolution
+
+            if count == 1:
+                # resample beamsize only 3 times
+                return np.nan, np.nan, np.nan, np.nan
+
+            count = count + 1
+
+
+    else:
+
+        # make sure stats is checked on profmon gui
+        if use_profMon:
+            xrms, xrms_err = x_size_pv.get() * 1e-6, 0  # in meters
+            yrms, yrms_err = y_size_pv.get() * 1e-6, 0  # in meters
+            #print("Using ProfMon beamsizes.")
+
+        else:
+            if post:
+                beamsizes = getbeamsizes_from_img(post=post)
+            else:
+                beamsizes = getbeamsizes_from_img()
+
+            xrms = beamsizes[0]
+            yrms = beamsizes[1]
+            xrms_err = beamsizes[2]
+            yrms_err = beamsizes[3]
+            xamp = beamsizes[4]
+            yamp = beamsizes[5]
+            # im = beamsizes[6]
+
+            # convert to meters
+            xrms = xrms * resolution
+            yrms = yrms * resolution
+            xrms_err = xrms_err * resolution
+            yrms_err = yrms_err * resolution
+
+    if save_summary:
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+        save_config(xrms, yrms, xrms_err, yrms_err, timestamp)
+        numpy_save(xrms, yrms, xrms_err, yrms_err, timestamp)
+
+    return xrms, yrms, xrms_err, yrms_err
+
+def getbeamsizes_from_img(num_images=n_acquire, avg=avg_ims,
+                          subtract_bg=subtract_bg, post=None):
+    """Returns xrms, yrms, xrms_err, yrms_err for multiple sampled images;
+    can optionally average multiple images
+    RETURNS IN RAW PIXEL UNITS-- NEED TO MULTIPLY BY RESOLUTION FOR METERS
+    """
+
+    xrms, yrms = [0] * num_images, [0] * num_images
+    xrms_err, yrms_err = [0] * num_images, [0] * num_images
+    xamp, yamp, im = [0] * num_images, [0] * num_images, [0] * num_images
+
+    if post:
+        ncol = post[0][1]
+        nrow = post[0][2]
+    else:
+        ncol, nrow = n_col_pv.get(), n_row_pv.get()
+
+    for i in range(0, num_images):
+
+        repeat = True
+        count = 0
+
+        # retake bad images
+        while repeat:
+            meas = get_beam_image(subtract_bg, post)
+            xrms[i], yrms[i] = meas[0:2]
+            xrms_err[i], yrms_err[i] = meas[2:4]
+            xamp[i], yamp[i], im[i] = meas[4:]
+
+            # plt.imshow(im[i])
+            # plt.show()
+
+            count = count + 1
+
+            if xamp[i] > amp_threshold_x and yamp[i] > amp_threshold_y \
+                    and xrms[i] > min_sigma and yrms[i] > min_sigma \
+                    and xrms[i] < max_sigma and yrms[i] < max_sigma:
+                # if conditions are met, stop resampling this image
+                repeat = False
+            elif count == 3:
+                # if still bad after 3 tries, return nan
+                xrms[i], yrms[i], xrms_err[i], yrms_err[i], xamp[i], yamp[
+                    i] = np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
+                repeat = False
+
+    # average images before taking fits
+    if avg == True:
+
+        im = np.mean(im, axis=0)
+
+        im = Image(im, ncol, nrow, bg_image=bg_image)
+
+        im.reshape_im()
+        if subtract_bg:
+            im.subtract_bg()
+        im.get_im_projection()
+
+        # plt.imshow(im.proc_image)
+
+        meas =  im.get_sizes(show_plots=False)
+        mean_xrms, mean_yrms = meas[0:2]
+        mean_xrms_err, mean_yrms_err = meas[2:4]
+        mean_xamp, mean_yamp = meas[4:]
+
+        if mean_xamp < amp_threshold_x or mean_yamp < amp_threshold_y:
+            return [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan]
+
+        # save_beam = list(np.array(beamsizes[0:4])*resolution/1e-6)
+
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+        # pass beamsizes in um
+        save_image(im.proc_image, ncol, nrow, timestamp, avg_img=True)
+
+        return [mean_xrms, mean_yrms,
+                mean_xrms_err, mean_yrms_err,
+                mean_xamp, mean_yamp, im.proc_image]
+
+
+    # average individual rms fits
+    else:
+        idx = ~np.isnan(xrms)
+
+        if True not in idx:
+            return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan
+
+        mean_xrms = np.mean(np.array(xrms)[idx])
+        mean_yrms = np.mean(np.array(yrms)[idx])
+        mean_xrms_err = np.std(np.array(xrms)[idx]) / np.sqrt(len(idx))
+        mean_yrms_err = np.std(np.array(yrms)[idx]) / np.sqrt(len(idx))
+        mean_xamp = np.mean(np.array(xamp)[idx])
+        mean_yamp = np.mean(np.array(yamp)[idx])
+
+        im = Image(im[0], ncol, nrow, bg_image=bg_image)
+
+        im.reshape_im()
+        im.get_im_projection()
+
+        return [mean_xrms, mean_yrms,
+                mean_xrms_err, mean_yrms_err,
+                mean_xamp, mean_yamp, im.proc_image]
+
+def get_beam_image(subtract_bg=subtract_bg, post=None):
+    """Get beam image from screen
+    Return beamsize info and processed image
+    """
+
+    if post:
+        im = post[0]
+        ncol = post[1]
+        nrow = post[2]
+    else:
+        im = im_pv.get()
+        ncol, nrow = n_col_pv.get(), n_row_pv.get()
+
+    beam_image = Image(im, ncol, nrow, bg_image=bg_image)
+    beam_image.reshape_im()
+
+    if subtract_bg:
+        beam_image.subtract_bg()
+
+    if use_roi:
+        beam_image.proc_image = beam_image.proc_image[roi_ymin:roi_ymax, roi_xmin:roi_xmax]
+
+    beam_image.get_im_projection()
+
+    # fit the profile and return the beamsizes
+    beamsizes = beam_image.get_sizes(show_plots=False)
+
+    # save_beam = list(np.array(beamsizes[0:4])*resolution/1e-6)
+
+    timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+    # savesummary(beamsizes,timestamp)# pass beamsizes in um
+    save_image(im, ncol, nrow, timestamp, avg_img=False)
+
+    return list(beamsizes) + [beam_image.proc_image]
\ No newline at end of file
diff --git a/pyemittance/saving_io.py b/pyemittance/saving_io.py
new file mode 100644
index 0000000..36f5490
--- /dev/null
+++ b/pyemittance/saving_io.py
@@ -0,0 +1,136 @@
+import numpy as np
+from os import path, makedirs
+from os.path import exists
+import errno, os
+import json
+import datetime
+from epics import caget, caget_many
+
+### '''''CHANGE HERE ''' #TODO: update config settings
+meas_type = 'OTRS'
+#################
+
+if meas_type == 'WIRE':
+    add_path = '/LCLS_WS02'
+elif meas_type == 'OTRS':
+    add_path = '/LCLS2_OTR3'
+else:
+    add_path = ''
+
+this_dir, this_filename = path.split(__file__)
+CONFIG_PATH = path.join(this_dir, 'configs' + add_path)
+pv_savelist = json.load(open(CONFIG_PATH+'/save_scalar_pvs.json'))
+savepaths = json.load(open(CONFIG_PATH+'/savepaths.json'))
+opt_pv_info = json.load(open(CONFIG_PATH+'/opt_pv_info.json'))
+meas_pv_info = json.load(open(CONFIG_PATH+'/meas_pv_info.json'))
+
+meas_read_pv = meas_pv_info['meas_device']['pv']['read']
+opt_pvs = opt_pv_info['opt_vars']
+
+
+def mkdir_p(path):
+    """Set up dirs for results in working dir"""
+    try:
+        makedirs(path)
+    except OSError as exc:
+        if exc.errno == errno.EEXIST and os.path.isdir(path):
+            pass
+        else:
+            raise
+
+# Make directories if needed
+mkdir_p(savepaths['images'])
+mkdir_p(savepaths['summaries'])
+mkdir_p(savepaths['fits'])
+mkdir_p(savepaths['raw_saves'])
+
+# Start headings
+file_exists = path.exists(savepaths['summaries'] + "image_acq_quad_info.csv")
+
+if not file_exists:
+
+    # todo add others as inputs
+    f = open(savepaths['summaries'] + "image_acq_quad_info.csv", "a+")
+    f.write(
+        f"{'timestamp'},{'ncol'},{'nrow'},{'roi_xmin'},{'roi_xmax'}"
+        f",{'roi_ymin'},{'roi_ymax'},{'resolution'},{'bact'},"
+        f"{'x_size'},{'y_size'},{'beamsizes[0]'},{'beamsizes[1]'},"
+        f"{'beamsizes[2]'},{'beamsizes[3]'}\n")
+    f.close()
+
+file_exists = path.exists(savepaths['summaries'] + "beamsize_config_info.csv")
+
+if not file_exists:
+    # todo add others as inputs
+    f = open(savepaths['summaries'] + "beamsize_config_info.csv", "a+")
+    f.write(
+        f"{'timestamp'},{'varx_cur'},{'vary_cur'},{'varz_cur'},"
+        f"{'bact_cur'},{'xrms'},{'yrms'},{'xrms_err'},{'yrms_err'}\n")
+    f.close()
+
+
+def isotime():
+    return datetime.datetime.utcnow().replace(tzinfo=datetime.timezone.utc).\
+        astimezone().replace(microsecond=0).isoformat()
+
+def save_image(im, ncol, nrow, timestamp,
+              impath=savepaths['images'], avg_img=True):
+    """Saves images with col,row info and corresp. settings"""
+
+    if avg_img:
+
+        np.save(str(impath) + f'img_avg_{timestamp}.npy', im)
+        np.save(str(impath) + f'ncol_avg_{timestamp}.npy', ncol)
+        np.save(str(impath) + f'nrow_avg_{timestamp}.npy', nrow)
+
+    else:
+
+        np.save(str(impath) + f'img_{timestamp}.npy', im)
+        np.save(str(impath) + f'ncol_{timestamp}.npy', ncol)
+        np.save(str(impath) + f'nrow_{timestamp}.npy', nrow)
+
+
+def numpy_save(xrms, yrms, xrms_err, yrms_err, timestamp=False,
+               savelist=pv_savelist['scalars'],
+               path=savepaths['raw_saves']):
+    ts = isotime()
+    x = caget_many(savelist)
+    if timestamp:
+        x.append(timestamp)
+    else:
+        x.append(ts)
+    x.append(xrms)
+    x.append(yrms)
+    x.append(xrms_err)
+    x.append(yrms_err)
+
+    np.save(path + ts + '_pv_bs_data_.npy', np.array(x))
+
+
+def save_config(xrms, yrms, xrms_err, yrms_err, timestamp,
+                config_path=savepaths['summaries'],
+                 im=None,
+                impath=savepaths['images']):
+    if timestamp is None:
+        f = open(savepaths['summaries'] + "bax_beamsize_config_info.csv", "a+")
+        timestamp = isotime()
+    else:
+        f = open(savepaths['summaries'] + "beamsize_config_info.csv", "a+")
+
+    # todo make more general, pandas etc
+    varx_cur = caget(opt_pvs[0])
+    vary_cur = caget(opt_pvs[1])
+    varz_cur = caget(opt_pvs[2])
+    bact_cur = caget(meas_read_pv)
+    f.write(f"{timestamp},{varx_cur},{vary_cur},{varz_cur},"
+            f"{bact_cur},{xrms},{yrms},{xrms_err},{yrms_err}\n")
+
+    f.close()
+
+    if im:
+        np.save((str(impath) + f'img_config_{timestamp}.npy', im.proc_image))
+
+def save_emit_run(out_dict, path=savepaths['fits']):
+    timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+    with open(path + f"pyemittance_data_{timestamp}.json", "w") as outfile:
+        json.dump(out_dict, outfile)
diff --git a/pyemittance/wire_io.py b/pyemittance/wire_io.py
new file mode 100644
index 0000000..d248f07
--- /dev/null
+++ b/pyemittance/wire_io.py
@@ -0,0 +1,55 @@
+import numpy as np
+from os import path
+import json
+import time
+import datetime
+
+from epics import PV
+from pyemittance.saving_io import numpy_save, save_config
+
+
+this_dir, this_filename = path.split(__file__)
+CONFIG_PATH = path.join(this_dir, "configs/LCLS_WS02")
+
+# Measurement PVs
+meas_pv_info = json.load(open(CONFIG_PATH + '/meas_pv_info.json'))
+
+# in meters for emittance calc
+scan_pv = PV(meas_pv_info['diagnostic']['pv']['scan'])
+x_size_pv = PV(meas_pv_info['diagnostic']['pv']['xsize'])
+y_size_pv = PV(meas_pv_info['diagnostic']['pv']['ysize'])
+
+def get_beamsizes_wire(online=False, save_summary=False):
+    """Main function imported by beam_io
+    Returns xrms, yrms, xrms_err, yrms_err
+    """
+    # run wire scans
+    get_beamsize(online=online)
+    
+    # read in PVs 
+    xrms = x_size_pv.get()*1e-6
+    yrms = y_size_pv.get()*1e-6
+    # add some error estimate
+    xrms_err = xrms*0.02
+    yrms_err = yrms*0.02
+    
+    if save_summary:
+        timestamp = (datetime.datetime.now()).strftime("%Y-%m-%d_%H-%M-%S-%f")
+        save_config(xrms, yrms, xrms_err, yrms_err, timestamp)
+        numpy_save(xrms, yrms, xrms_err, yrms_err, timestamp)
+    
+    return xrms, yrms, xrms_err, yrms_err
+
+def get_beamsize(online):
+    if online:
+        scan_pv.put(1)
+        time.sleep(1)  
+        
+        status = scan_pv.get()
+        if status == 2:
+            while scan_pv.get()!= 0:
+                time.sleep(5) 
+            time.sleep(3) # to not break the wire scanner
+             
+        else: 
+            print(f"WS did not run. Status {status}.")
\ No newline at end of file
diff --git a/setup.py b/setup.py
index f1fab0f..9e5185a 100644
--- a/setup.py
+++ b/setup.py
@@ -9,7 +9,7 @@
 
 setup(
     name='pyemittance',
-    version='v0.1.1',
+    version='v0.3.3',
     author='Sara Miskovich',
     author_email='smiskov@slac.stanford.edu',
     packages=find_packages(),


Test patch:
diff --git a/examples/simple_fit_test.ipynb b/examples/simple_fit_test.ipynb
index cebef98..2610319 100644
--- a/examples/simple_fit_test.ipynb
+++ b/examples/simple_fit_test.ipynb
@@ -8,8 +8,16 @@
    "outputs": [],
    "source": [
     "import numpy as np\n",
-    "from pyemittance.emittance_calc import EmitCalc\n",
-    "from pyemittance.optics import quad_rmat_mat2, propagate_sigma"
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# For creating data\n",
+    "from pyemittance.optics import quad_rmat_mat2, propagate_sigma\n",
+    "\n",
+    "# Import pyemittance modules\n",
+    "# Handles I/O of data\n",
+    "from pyemittance.observer import Observer\n",
+    "# Handles optics and emittance/bmag calc\n",
+    "from pyemittance.emittance_calc import EmitCalc"
    ]
   },
   {
@@ -58,7 +66,6 @@
     "    sigma1 = propagate_sigma(sigma0, mat2)\n",
     "    return np.sqrt(sigma1[0,0])\n",
     "\n",
-    "@np.vectorize\n",
     "def model(kL):\n",
     "    return beam_size_meas(kL, SIGMA0, Ltot=2.26, Lquad=0.108)\n",
     "\n",
@@ -77,7 +84,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fd86027f110>"
+       "<matplotlib.legend.Legend at 0x7fce601c3d90>"
       ]
      },
      "execution_count": 4,
@@ -98,8 +105,6 @@
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
     "plt.scatter(kLlist, meas*1e6, label='thick quad model')\n",
     "plt.xlabel(r'quad k1 (1/m$^2$)')\n",
     "plt.ylabel('Beam size (µm)')\n",
@@ -111,29 +116,23 @@
    "id": "c1a6121d",
    "metadata": {},
    "source": [
-    "# Fit data w/ PyEmittance"
+    "# Fit data w/ PyEmittance: this can be used with any given dataset\n",
+    "Units needed: \n",
+    "- kGauss for quadrupole strengths\n",
+    "- meters for beam sizes and beam sizes errors\n",
+    "\n",
+    "- returns emittance in m*rad"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "005f3e26",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from pyemittance.observer import Observer\n",
-    "from pyemittance.emittance_calc import EmitCalc"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
    "id": "252061bb",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -143,16 +142,9 @@
      },
      "output_type": "display_data"
     },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "emit: 1.17, emit err: 0.0389, bs er: 0.0398\n"
-     ]
-    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -163,54 +155,139 @@
      "output_type": "display_data"
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "emit: 1.17, emit err: 0.0389, bs er: 0.0398\n"
-     ]
+     "data": {
+      "text/plain": [
+       "{'nemitx': 1.1733253878383434e-06,\n",
+       " 'nemity': 1.1733253878383434e-06,\n",
+       " 'nemitx_err': 2.331865862605872e-08,\n",
+       " 'nemity_err': 2.331865862605872e-08,\n",
+       " 'nemit': None,\n",
+       " 'nemit_err': None,\n",
+       " 'bmagx': None,\n",
+       " 'bmagy': None,\n",
+       " 'bmagx_err': None,\n",
+       " 'bmagy_err': None,\n",
+       " 'opt_q_x': None,\n",
+       " 'opt_q_y': None,\n",
+       " 'quadvalsx': [0.2,\n",
+       "  0.25555555555555554,\n",
+       "  0.3111111111111111,\n",
+       "  0.3666666666666667,\n",
+       "  0.4222222222222222,\n",
+       "  0.4777777777777778,\n",
+       "  0.5333333333333333,\n",
+       "  0.5888888888888888,\n",
+       "  0.6444444444444444,\n",
+       "  0.7],\n",
+       " 'beamsizesx': [8.078981084043802e-05,\n",
+       "  6.859816262759632e-05,\n",
+       "  5.6707770179325505e-05,\n",
+       "  4.5334684264821755e-05,\n",
+       "  3.495928358934615e-05,\n",
+       "  2.6731769519479044e-05,\n",
+       "  2.3034979932358345e-05,\n",
+       "  2.5851397939242495e-05,\n",
+       "  3.355177979658439e-05,\n",
+       "  4.360021646817196e-05],\n",
+       " 'beamsizeserrx': [2.4236943252131404e-06,\n",
+       "  2.0579448788278898e-06,\n",
+       "  1.7012331053797651e-06,\n",
+       "  1.3600405279446527e-06,\n",
+       "  1.0487785076803844e-06,\n",
+       "  8.019530855843713e-07,\n",
+       "  6.910493979707503e-07,\n",
+       "  7.755419381772748e-07,\n",
+       "  1.0065533938975318e-06,\n",
+       "  1.3080064940451588e-06],\n",
+       " 'quadvalsy': [0.2,\n",
+       "  0.25555555555555554,\n",
+       "  0.3111111111111111,\n",
+       "  0.3666666666666667,\n",
+       "  0.4222222222222222,\n",
+       "  0.4777777777777778,\n",
+       "  0.5333333333333333,\n",
+       "  0.5888888888888888,\n",
+       "  0.6444444444444444,\n",
+       "  0.7],\n",
+       " 'beamsizesy': [8.078981084043802e-05,\n",
+       "  6.859816262759632e-05,\n",
+       "  5.6707770179325505e-05,\n",
+       "  4.5334684264821755e-05,\n",
+       "  3.495928358934615e-05,\n",
+       "  2.6731769519479044e-05,\n",
+       "  2.3034979932358345e-05,\n",
+       "  2.5851397939242495e-05,\n",
+       "  3.355177979658439e-05,\n",
+       "  4.360021646817196e-05],\n",
+       " 'beamsizeserry': [2.4236943252131404e-06,\n",
+       "  2.0579448788278898e-06,\n",
+       "  1.7012331053797651e-06,\n",
+       "  1.3600405279446527e-06,\n",
+       "  1.0487785076803844e-06,\n",
+       "  8.019530855843713e-07,\n",
+       "  6.910493979707503e-07,\n",
+       "  7.755419381772748e-07,\n",
+       "  1.0065533938975318e-06,\n",
+       "  1.3080064940451588e-06]}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
     "# Observer class handles all I/O\n",
     "# avoids repeating measurements within an emittance calc\n",
-    "o1 = Observer(kLlist, {'x': meas ,'y': meas} )\n",
+    "ef = EmitCalc({'x': kLlist,'y': kLlist},\n",
+    "              {'x': meas ,'y': meas},\n",
+    "              {'x': meas*0.03 ,'y': meas*0.03}\n",
+    "             )\n",
+    "ef.plot = True\n",
+    "ef.save_runs = False\n",
+    "\n",
+    "ef.get_emit()\n",
     "\n",
-    "ef1 = EmitCalc(o1.quad_meas, o1.beam_meas)\n",
-    "ef1.plot = True\n",
     "\n",
-    "emitx, erry = ef1.get_emit(dim='x')\n",
-    "emity, erry = ef1.get_emit(dim='y')"
+    "ef.out_dict"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "8e78e148",
    "metadata": {},
    "outputs": [],
    "source": [
-    "bmagx, bmagx_err = ef1.get_twiss_bmag(dim='x')"
+    "ef = EmitCalc({'x': kLlist,'y': kLlist},\n",
+    "              {'x': meas ,'y': meas},\n",
+    "              {'x': meas*0.03 ,'y': meas*0.03}\n",
+    "             )\n",
+    "ef.calc_bmag = True \n",
+    "ef.save_runs = False\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "674c5c20",
+   "execution_count": 7,
+   "id": "6add8343",
    "metadata": {},
    "outputs": [
     {
      "data": {
+      "image/png": "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\n",
       "text/plain": [
-       "Text(0, 0.5, 'Bmag (1)')"
+       "<Figure size 432x288 with 1 Axes>"
       ]
      },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -219,41 +296,98 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "fig, ax = plt.subplots()\n",
-    "\n",
-    "ax.plot(kLlist, bmagx)\n",
-    "ax.set_xlabel('kL (1/m)')\n",
-    "ax.set_ylabel('Bmag (1)')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "b83ff7b0",
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
       "text/plain": [
-       "0.033098968831347976"
+       "{'nemitx': 1.1733253878383434e-06,\n",
+       " 'nemity': 1.1733253878383434e-06,\n",
+       " 'nemitx_err': 2.331865862605872e-08,\n",
+       " 'nemity_err': 2.331865862605872e-08,\n",
+       " 'nemit': None,\n",
+       " 'nemit_err': None,\n",
+       " 'bmagx': 4.057961241777015,\n",
+       " 'bmagy': 4.061644963098544,\n",
+       " 'bmagx_err': 0.08064788667742774,\n",
+       " 'bmagy_err': 0.08072109692316183,\n",
+       " 'opt_q_x': 0.2,\n",
+       " 'opt_q_y': 0.2,\n",
+       " 'quadvalsx': [0.2,\n",
+       "  0.25555555555555554,\n",
+       "  0.3111111111111111,\n",
+       "  0.3666666666666667,\n",
+       "  0.4222222222222222,\n",
+       "  0.4777777777777778,\n",
+       "  0.5333333333333333,\n",
+       "  0.5888888888888888,\n",
+       "  0.6444444444444444,\n",
+       "  0.7],\n",
+       " 'beamsizesx': [8.078981084043802e-05,\n",
+       "  6.859816262759632e-05,\n",
+       "  5.6707770179325505e-05,\n",
+       "  4.5334684264821755e-05,\n",
+       "  3.495928358934615e-05,\n",
+       "  2.6731769519479044e-05,\n",
+       "  2.3034979932358345e-05,\n",
+       "  2.5851397939242495e-05,\n",
+       "  3.355177979658439e-05,\n",
+       "  4.360021646817196e-05],\n",
+       " 'beamsizeserrx': [2.4236943252131404e-06,\n",
+       "  2.0579448788278898e-06,\n",
+       "  1.7012331053797651e-06,\n",
+       "  1.3600405279446527e-06,\n",
+       "  1.0487785076803844e-06,\n",
+       "  8.019530855843713e-07,\n",
+       "  6.910493979707503e-07,\n",
+       "  7.755419381772748e-07,\n",
+       "  1.0065533938975318e-06,\n",
+       "  1.3080064940451588e-06],\n",
+       " 'quadvalsy': [0.2,\n",
+       "  0.25555555555555554,\n",
+       "  0.3111111111111111,\n",
+       "  0.3666666666666667,\n",
+       "  0.4222222222222222,\n",
+       "  0.4777777777777778,\n",
+       "  0.5333333333333333,\n",
+       "  0.5888888888888888,\n",
+       "  0.6444444444444444,\n",
+       "  0.7],\n",
+       " 'beamsizesy': [8.078981084043802e-05,\n",
+       "  6.859816262759632e-05,\n",
+       "  5.6707770179325505e-05,\n",
+       "  4.5334684264821755e-05,\n",
+       "  3.495928358934615e-05,\n",
+       "  2.6731769519479044e-05,\n",
+       "  2.3034979932358345e-05,\n",
+       "  2.5851397939242495e-05,\n",
+       "  3.355177979658439e-05,\n",
+       "  4.360021646817196e-05],\n",
+       " 'beamsizeserry': [2.4236943252131404e-06,\n",
+       "  2.0579448788278898e-06,\n",
+       "  1.7012331053797651e-06,\n",
+       "  1.3600405279446527e-06,\n",
+       "  1.0487785076803844e-06,\n",
+       "  8.019530855843713e-07,\n",
+       "  6.910493979707503e-07,\n",
+       "  7.755419381772748e-07,\n",
+       "  1.0065533938975318e-06,\n",
+       "  1.3080064940451588e-06]}"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "np.mean(bmagx_err/bmagx)"
+    "ef.plot = True\n",
+    "ef.get_emit()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "fa394e49",
+   "id": "77fef0c1-773c-4741-83d5-04f501009abb",
    "metadata": {},
    "outputs": [],
    "source": []
diff --git a/pyemittance/configs/latest_facet/beamline_info.json b/pyemittance/configs/latest_facet/beamline_info.json
new file mode 100644
index 0000000..ebef231
--- /dev/null
+++ b/pyemittance/configs/latest_facet/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "FACET-II", "m_0": 0.000511, "d": 2.7012, "l": 0.108, "energy": 0.125, "Twiss0": [5.3e-06, 4.9e-06, 1.1106, 1.1106, -0.0979, -0.0979], "rMat": [1, 2.7012, 0, 1] }
\ No newline at end of file
diff --git a/pyemittance/configs/latest_facet/img_proc.json b/pyemittance/configs/latest_facet/img_proc.json
new file mode 100644
index 0000000..d606b93
--- /dev/null
+++ b/pyemittance/configs/latest_facet/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": true, "use_roi": false, "avg_ims": true, "n_to_acquire": 4, "background_im":"/home/fphysics/smiskov/20220227/background_571.npy", "amp_threshold": 10, "min_sigma": 1.0, "max_sigma": 10000, "max_samples": 1, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/latest_facet/meas_pv_info.json b/pyemittance/configs/latest_facet/meas_pv_info.json
new file mode 100644
index 0000000..796b41c
--- /dev/null
+++ b/pyemittance/configs/latest_facet/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "PROF:IN10:571", "image": "PROF:IN10:571:Image:ArrayData", "ncol": "PROF:IN10:571:Image:ArraySize1_RBV", "nrow": "PROF:IN10:571:Image:ArraySize0_RBV", "resolution": "PROF:IN10:571:RESOLUTION", "profmonxsize": "PROF:IN10:571:XRMS", "profmonysize": "PROF:IN10:571:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN10:525", "cntrl": "QUAD:IN10:525:BCTRL", "read": "QUAD:IN10:525:BACT","min":-8.5,"max":-2.0}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN10:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/latest_facet/opt_pv_info.json b/pyemittance/configs/latest_facet/opt_pv_info.json
new file mode 100644
index 0000000..00ed2d4
--- /dev/null
+++ b/pyemittance/configs/latest_facet/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN10:121:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/latest_facet/save_scalar_pvs.json b/pyemittance/configs/latest_facet/save_scalar_pvs.json
new file mode 100644
index 0000000..066938e
--- /dev/null
+++ b/pyemittance/configs/latest_facet/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN10:121:BACT", "SOLN:IN10:111:BACT", "QUAD:IN10:121:BACT", "QUAD:IN10:122:BACT", "QUAD:IN10:361:BACT", "QUAD:IN10:371:BACT", "QUAD:IN10:425:BACT", "QUAD:IN10:441:BACT", "QUAD:IN10:511:BACT", "QUAD:IN10:525:BACT", "SOLN:IN10:121:BCTRL", "SOLN:IN10:111:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL", "KLYS:LI10:21:PHAS", "KLYS:LI10:21:AMPL", "KLYS:LI10:51:PHAS", "PROF:IN10:571:XRMS", "PROF:IN10:571:YRMS", "PROF:IN10:571:X", "PROF:IN10:571:Y", "TORO:IN10:791:0:TMIT_PC", "PROF:IN10:571:RESOLUTION", "CAMR:LT10:900:RESOLUTION", "PROF:IN10:571:Image:ArraySize0_RBV", "PROF:IN10:571:Image:ArraySize1_RBV", "CAMR:LT10:900:Image:ArraySize0_RBV", "CAMR:LT10:900:Image:ArraySize1_RBV"]}
\ No newline at end of file
diff --git a/pyemittance/configs/latest_facet/savepaths.json b/pyemittance/configs/latest_facet/savepaths.json
new file mode 100644
index 0000000..bd68dd2
--- /dev/null
+++ b/pyemittance/configs/latest_facet/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/fphysics/smiskov/202205/saved_fits/", "images": "/home/fphysics/smiskov/202205/saved_images/", "monitoring": "/home/fphysics/smiskov/202205/monitoring/", "summaries": "/home/fphysics/smiskov/202205/summaries/", "raw_saves": "/home/fphysics/smiskov/202205/raw_saves/", "emit_saves": "/home/fphysics/smiskov/202205/emit_saves/", "mon_saves": "/home/fphysics/smiskov/202205/mon_saves/", "xopt_saves": "/home/fphysics/smiskov/202205/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/latest_facet/beamline_info.json b/pyemittance/configs/other_configs/latest_facet/beamline_info.json
new file mode 100644
index 0000000..ebef231
--- /dev/null
+++ b/pyemittance/configs/other_configs/latest_facet/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "FACET-II", "m_0": 0.000511, "d": 2.7012, "l": 0.108, "energy": 0.125, "Twiss0": [5.3e-06, 4.9e-06, 1.1106, 1.1106, -0.0979, -0.0979], "rMat": [1, 2.7012, 0, 1] }
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/latest_facet/img_proc.json b/pyemittance/configs/other_configs/latest_facet/img_proc.json
new file mode 100644
index 0000000..d606b93
--- /dev/null
+++ b/pyemittance/configs/other_configs/latest_facet/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": true, "use_roi": false, "avg_ims": true, "n_to_acquire": 4, "background_im":"/home/fphysics/smiskov/20220227/background_571.npy", "amp_threshold": 10, "min_sigma": 1.0, "max_sigma": 10000, "max_samples": 1, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/latest_facet/meas_pv_info.json b/pyemittance/configs/other_configs/latest_facet/meas_pv_info.json
new file mode 100644
index 0000000..796b41c
--- /dev/null
+++ b/pyemittance/configs/other_configs/latest_facet/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "PROF:IN10:571", "image": "PROF:IN10:571:Image:ArrayData", "ncol": "PROF:IN10:571:Image:ArraySize1_RBV", "nrow": "PROF:IN10:571:Image:ArraySize0_RBV", "resolution": "PROF:IN10:571:RESOLUTION", "profmonxsize": "PROF:IN10:571:XRMS", "profmonysize": "PROF:IN10:571:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN10:525", "cntrl": "QUAD:IN10:525:BCTRL", "read": "QUAD:IN10:525:BACT","min":-8.5,"max":-2.0}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN10:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/latest_facet/opt_pv_info.json b/pyemittance/configs/other_configs/latest_facet/opt_pv_info.json
new file mode 100644
index 0000000..00ed2d4
--- /dev/null
+++ b/pyemittance/configs/other_configs/latest_facet/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN10:121:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/latest_facet/save_scalar_pvs.json b/pyemittance/configs/other_configs/latest_facet/save_scalar_pvs.json
new file mode 100644
index 0000000..066938e
--- /dev/null
+++ b/pyemittance/configs/other_configs/latest_facet/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN10:121:BACT", "SOLN:IN10:111:BACT", "QUAD:IN10:121:BACT", "QUAD:IN10:122:BACT", "QUAD:IN10:361:BACT", "QUAD:IN10:371:BACT", "QUAD:IN10:425:BACT", "QUAD:IN10:441:BACT", "QUAD:IN10:511:BACT", "QUAD:IN10:525:BACT", "SOLN:IN10:121:BCTRL", "SOLN:IN10:111:BCTRL", "QUAD:IN10:121:BCTRL", "QUAD:IN10:122:BCTRL", "QUAD:IN10:361:BCTRL", "QUAD:IN10:371:BCTRL", "QUAD:IN10:425:BCTRL", "QUAD:IN10:441:BCTRL", "QUAD:IN10:511:BCTRL", "QUAD:IN10:525:BCTRL", "KLYS:LI10:21:PHAS", "KLYS:LI10:21:AMPL", "KLYS:LI10:51:PHAS", "PROF:IN10:571:XRMS", "PROF:IN10:571:YRMS", "PROF:IN10:571:X", "PROF:IN10:571:Y", "TORO:IN10:791:0:TMIT_PC", "PROF:IN10:571:RESOLUTION", "CAMR:LT10:900:RESOLUTION", "PROF:IN10:571:Image:ArraySize0_RBV", "PROF:IN10:571:Image:ArraySize1_RBV", "CAMR:LT10:900:Image:ArraySize0_RBV", "CAMR:LT10:900:Image:ArraySize1_RBV"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/latest_facet/savepaths.json b/pyemittance/configs/other_configs/latest_facet/savepaths.json
new file mode 100644
index 0000000..bd68dd2
--- /dev/null
+++ b/pyemittance/configs/other_configs/latest_facet/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/fphysics/smiskov/202205/saved_fits/", "images": "/home/fphysics/smiskov/202205/saved_images/", "monitoring": "/home/fphysics/smiskov/202205/monitoring/", "summaries": "/home/fphysics/smiskov/202205/summaries/", "raw_saves": "/home/fphysics/smiskov/202205/raw_saves/", "emit_saves": "/home/fphysics/smiskov/202205/emit_saves/", "mon_saves": "/home/fphysics/smiskov/202205/mon_saves/", "xopt_saves": "/home/fphysics/smiskov/202205/xopt_saves/"}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/test/beamline_info.json b/pyemittance/configs/other_configs/test/beamline_info.json
new file mode 100644
index 0000000..90fb313
--- /dev/null
+++ b/pyemittance/configs/other_configs/test/beamline_info.json
@@ -0,0 +1,1 @@
+{"name": "LCLS", "m_0": 0.000511, "d": 2.26, "l": 0.108, "energy": 0.135, "Twiss0": [1e-6, 1e-6, 1.113081026, 1.113021659, -6.89403587e-2, -7.029489754e-2], "rMat": [1, 2.26, 0, 1] }
diff --git a/pyemittance/configs/other_configs/test/img_proc.json b/pyemittance/configs/other_configs/test/img_proc.json
new file mode 100644
index 0000000..3f34b53
--- /dev/null
+++ b/pyemittance/configs/other_configs/test/img_proc.json
@@ -0,0 +1,1 @@
+{"subtract_bg": false, "use_roi": false, "avg_ims": true, "n_to_acquire": 5, "background_im": null, "amp_threshold": 200, "min_sigma": 2e-8, "max_sigma": 0.1, "max_samples": 3, "roi": {"xmin": 0, "xmax": 100, "ymin": 0, "ymax": 100}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/test/meas_pv_info.json b/pyemittance/configs/other_configs/test/meas_pv_info.json
new file mode 100644
index 0000000..6f349fb
--- /dev/null
+++ b/pyemittance/configs/other_configs/test/meas_pv_info.json
@@ -0,0 +1,1 @@
+{"diagnostic": {"pv": {"name": "OTRS:IN20:541", "image": "OTRS:IN20:541:IMAGE", "ncol": "OTRS:IN20:541:ROI_YNP", "nrow": "OTRS:IN20:541:ROI_XNP", "resolution": "OTRS:IN20:541:RESOLUTION", "profmonxsize": "OTRS:IN20:541:XRMS", "profmonysize": "OTRS:IN20:541:YRMS"}, "pv_unit": {"resolution": "(um)"}}, "meas_device": {"pv": {"name": "QUAD:IN20:425", "cntrl": "QUAD:IN20:425:BCTRL", "read": "QUAD:IN20:425:BACT"}, "pv_unit": "kG"}, "beam_info": {"energy": "REFS:IN20:751:EDES"}}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/test/opt_pv_info.json b/pyemittance/configs/other_configs/test/opt_pv_info.json
new file mode 100644
index 0000000..58a6c12
--- /dev/null
+++ b/pyemittance/configs/other_configs/test/opt_pv_info.json
@@ -0,0 +1,1 @@
+{"opt_vars": ["SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL"], "opt_var_units": ["(kG*m)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)", "(kG)"], "input_vars": []}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/test/save_scalar_pvs.json b/pyemittance/configs/other_configs/test/save_scalar_pvs.json
new file mode 100644
index 0000000..cdb22dc
--- /dev/null
+++ b/pyemittance/configs/other_configs/test/save_scalar_pvs.json
@@ -0,0 +1,1 @@
+{"scalars": ["SOLN:IN20:121:BACT", "QUAD:IN20:121:BACT", "QUAD:IN20:122:BACT", "QUAD:IN20:361:BACT", "QUAD:IN20:371:BACT", "QUAD:IN20:425:BACT", "QUAD:IN20:441:BACT", "QUAD:IN20:511:BACT", "QUAD:IN20:525:BACT", "SOLN:IN20:121:BCTRL", "QUAD:IN20:121:BCTRL", "QUAD:IN20:122:BCTRL", "QUAD:IN20:361:BCTRL", "QUAD:IN20:371:BCTRL", "QUAD:IN20:425:BCTRL", "QUAD:IN20:441:BCTRL", "QUAD:IN20:511:BCTRL", "QUAD:IN20:525:BCTRL", "OTRS:IN20:541:XRMS", "OTRS:IN20:541:YRMS", "OTRS:IN20:541:X", "OTRS:IN20:541:Y", "OTRS:IN20:541:RESOLUTION"]}
\ No newline at end of file
diff --git a/pyemittance/configs/other_configs/test/savepaths.json b/pyemittance/configs/other_configs/test/savepaths.json
new file mode 100644
index 0000000..7e570ec
--- /dev/null
+++ b/pyemittance/configs/other_configs/test/savepaths.json
@@ -0,0 +1,1 @@
+{"fits": "/home/physics3/ml_tuning/20220803/saved_fits/", "images": "/home/physics3/ml_tuning/20220803/saved_images/", "monitoring": "/home/physics3/ml_tuning/20220803/monitoring/", "summaries": "/home/physics3/ml_tuning/20220803/summaries/", "raw_saves": "/home/physics3/ml_tuning/20220803/raw_saves/", "emit_saves": "/home/physics3/ml_tuning/20220803/emit_saves/", "mon_saves": "/home/physics3/ml_tuning/20220803/mon_saves/", "xopt_saves": "/home/physics3/ml_tuning/20220803/xopt_saves/"}
\ No newline at end of file