diff --git a/README.md b/README.md
index fa333aa..147972a 100644
--- a/README.md
+++ b/README.md
@@ -50,6 +50,12 @@ adler -s 8268570668335894776
 ```
 This will currently print some phase curve information to the terminal.
 
+One can also read from a local database, for example:
+
+```
+adler -s 8268570668335894776 -i tests/data/testing_database.db
+```
+
 Notes:
 1) The single quotes around `'[dev]'` may not be required for your operating system.
 2) `pre-commit install` will initialize pre-commit for this local repository, so
diff --git a/notebooks/adler_demo/adler_demo.ipynb b/notebooks/adler_demo/adler_demo.ipynb
new file mode 100644
index 0000000..5694d63
--- /dev/null
+++ b/notebooks/adler_demo/adler_demo.ipynb
@@ -0,0 +1,590 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b7d20301-a262-4820-bb3a-7fb43e2556d6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:14.129116Z",
+     "iopub.status.busy": "2024-05-16T16:38:14.128827Z",
+     "iopub.status.idle": "2024-05-16T16:38:15.583700Z",
+     "shell.execute_reply": "2024-05-16T16:38:15.582986Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:14.129097Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from adler.dataclasses.AdlerPlanetoid import AdlerPlanetoid\n",
+    "from adler.science.PhaseCurve import PhaseCurve\n",
+    "from adler.utilities.plotting_utilities import plot_errorbar\n",
+    "import adler.utilities.science_utilities as sci_utils\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.gridspec as gridspec\n",
+    "import astropy.units as u"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2de26df9-d4e8-465e-9698-8db0219ebcdd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:15.585255Z",
+     "iopub.status.busy": "2024-05-16T16:38:15.584619Z",
+     "iopub.status.idle": "2024-05-16T16:38:15.588002Z",
+     "shell.execute_reply": "2024-05-16T16:38:15.587337Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:15.585234Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# notebook to show adler searching for outlying photometry\n",
+    "# we could simply use the adler api to do this, but let's demo the CLI that would be running on a server"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a82c036c-e922-4316-9cd6-74119bfe2357",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:15.589009Z",
+     "iopub.status.busy": "2024-05-16T16:38:15.588798Z",
+     "iopub.status.idle": "2024-05-16T16:38:15.603718Z",
+     "shell.execute_reply": "2024-05-16T16:38:15.602882Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:15.588995Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# ssObjectId of object to analyse\n",
+    "ssoid1 = \"6098332225018\"  # good test object\n",
+    "ssoid2 = \"6098332225018000\"  # fake outburst object\n",
+    "filt = \"r\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3715f85a-1939-4ebb-894b-b262ea84865c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:15.604948Z",
+     "iopub.status.busy": "2024-05-16T16:38:15.604643Z",
+     "iopub.status.idle": "2024-05-16T16:38:15.765721Z",
+     "shell.execute_reply": "2024-05-16T16:38:15.765102Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:15.604930Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# here we use an offline SQL database which contains the observations of the sso\n",
+    "fname = \"/home/jrob/lsst-adler/notebooks/gen_test_data/adler_demo_testing_database.db\"\n",
+    "planetoid1 = AdlerPlanetoid.construct_from_SQL(ssoid1, sql_filename=fname)\n",
+    "planetoid2 = AdlerPlanetoid.construct_from_SQL(ssoid2, sql_filename=fname)\n",
+    "\n",
+    "# or query DP0.3 directly when on RSP\n",
+    "# planetoid1 = AdlerPlanetoid.construct_from_RSP(ssoid1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43d4f906-c055-4dd6-abe5-b559b3992023",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:15.768171Z",
+     "iopub.status.busy": "2024-05-16T16:38:15.767880Z",
+     "iopub.status.idle": "2024-05-16T16:38:15.772145Z",
+     "shell.execute_reply": "2024-05-16T16:38:15.771604Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:15.768154Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "planetoid1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c5be63b-295a-4ec0-959d-bc27e2e50ca1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:15.773095Z",
+     "iopub.status.busy": "2024-05-16T16:38:15.772893Z",
+     "iopub.status.idle": "2024-05-16T16:38:15.808371Z",
+     "shell.execute_reply": "2024-05-16T16:38:15.807616Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:15.773080Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "planetoid1.__dict__"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8350af69-b369-4f96-b46d-f00865504505",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:15.809631Z",
+     "iopub.status.busy": "2024-05-16T16:38:15.809299Z",
+     "iopub.status.idle": "2024-05-16T16:38:16.363874Z",
+     "shell.execute_reply": "2024-05-16T16:38:16.363226Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:15.809611Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "fig = plot_errorbar(planetoid1, filt_list=[\"r\"], x_plot=\"midPointMjdTai\", y_plot=\"reduced_mag\")\n",
+    "fig = plot_errorbar(planetoid1, filt_list=[\"r\"], x_plot=\"phaseAngle\", y_plot=\"reduced_mag\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b334d23a-792c-42a3-a396-533987b08bee",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:16.365028Z",
+     "iopub.status.busy": "2024-05-16T16:38:16.364799Z",
+     "iopub.status.idle": "2024-05-16T16:38:16.830194Z",
+     "shell.execute_reply": "2024-05-16T16:38:16.829613Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:16.365012Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "fig = plot_errorbar(planetoid2, filt_list=[\"r\"], x_plot=\"midPointMjdTai\", y_plot=\"reduced_mag\")\n",
+    "fig = plot_errorbar(planetoid2, filt_list=[\"r\"], x_plot=\"phaseAngle\", y_plot=\"reduced_mag\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "598c6098-0ddf-470f-acc8-e1962d9abbb7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:16.831659Z",
+     "iopub.status.busy": "2024-05-16T16:38:16.831084Z",
+     "iopub.status.idle": "2024-05-16T16:38:16.834249Z",
+     "shell.execute_reply": "2024-05-16T16:38:16.833691Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:16.831640Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# inspect observations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c31d37ac-e020-4e1b-a47d-842d4d2f7e53",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:16.835361Z",
+     "iopub.status.busy": "2024-05-16T16:38:16.835001Z",
+     "iopub.status.idle": "2024-05-16T16:38:16.849517Z",
+     "shell.execute_reply": "2024-05-16T16:38:16.848946Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:16.835345Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "obs = planetoid1.observations_in_filter(filt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08860ab8-5b1b-49b5-9390-f379b5429b51",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:16.850788Z",
+     "iopub.status.busy": "2024-05-16T16:38:16.850311Z",
+     "iopub.status.idle": "2024-05-16T16:38:16.864473Z",
+     "shell.execute_reply": "2024-05-16T16:38:16.863848Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:16.850770Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "df_obs = pd.DataFrame(obs.__dict__)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "46852c0e-d4c4-4e2c-9c64-f8497898c3a4",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:16.865419Z",
+     "iopub.status.busy": "2024-05-16T16:38:16.865219Z",
+     "iopub.status.idle": "2024-05-16T16:38:16.894396Z",
+     "shell.execute_reply": "2024-05-16T16:38:16.893776Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:16.865405Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "df_obs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a1a8c2c3-0639-4a05-80ff-ae4231bdaf4a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:16.895808Z",
+     "iopub.status.busy": "2024-05-16T16:38:16.895268Z",
+     "iopub.status.idle": "2024-05-16T16:38:16.900887Z",
+     "shell.execute_reply": "2024-05-16T16:38:16.900322Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:16.895787Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "tmin = np.amin(np.floor(df_obs[\"midPointMjdTai\"]))  # mjd\n",
+    "tmax = np.amax(np.floor(df_obs[\"midPointMjdTai\"])) + 1  # mjd\n",
+    "tmin, tmax"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a50e7a2e-a16f-4d08-b096-d891a720bb2f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:16.902113Z",
+     "iopub.status.busy": "2024-05-16T16:38:16.901692Z",
+     "iopub.status.idle": "2024-05-16T16:38:17.097053Z",
+     "shell.execute_reply": "2024-05-16T16:38:17.096408Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:16.902095Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# cumulative data in filter\n",
+    "x_plot = \"midPointMjdTai\"\n",
+    "df_plot = df_obs.sort_values(x_plot)\n",
+    "\n",
+    "fig = plt.figure()\n",
+    "gs = gridspec.GridSpec(1, 1)\n",
+    "ax1 = plt.subplot(gs[0, 0])\n",
+    "\n",
+    "bins = np.arange(tmin, tmax + 1)\n",
+    "\n",
+    "values, base = np.histogram(df_plot[x_plot], bins=bins)\n",
+    "cumulative = np.cumsum(values)\n",
+    "ax1.plot(base[:-1] - base[0], cumulative, label=filt)\n",
+    "\n",
+    "data_mask = np.diff(cumulative) > 0\n",
+    "data_nights = base[1:-1][data_mask]\n",
+    "N_data = cumulative[1:][data_mask]\n",
+    "\n",
+    "ax1.scatter(data_nights - data_nights[0], N_data)\n",
+    "\n",
+    "ax1.set_xlabel(x_plot)\n",
+    "ax1.set_ylabel(\"number\")\n",
+    "ax1.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c2bcbd8-702a-468c-a96c-b1d2ee91e9ea",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:17.098165Z",
+     "iopub.status.busy": "2024-05-16T16:38:17.097942Z",
+     "iopub.status.idle": "2024-05-16T16:38:17.102814Z",
+     "shell.execute_reply": "2024-05-16T16:38:17.102289Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:17.098148Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# number of data points per night of new data\n",
+    "np.diff(N_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2c32de0b-71b4-459c-8a64-d181df4392cb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:17.103777Z",
+     "iopub.status.busy": "2024-05-16T16:38:17.103554Z",
+     "iopub.status.idle": "2024-05-16T16:38:17.119164Z",
+     "shell.execute_reply": "2024-05-16T16:38:17.118612Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:17.103761Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# nights when new data arrives\n",
+    "data_nights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80108e40-0417-4b82-b73f-4cdf872b4a4c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:17.120143Z",
+     "iopub.status.busy": "2024-05-16T16:38:17.119942Z",
+     "iopub.status.idle": "2024-05-16T16:38:17.132937Z",
+     "shell.execute_reply": "2024-05-16T16:38:17.132315Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:17.120128Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# write commands to simulate adler cli searching for phase curve outliers on incoming data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "78e209fa-7cd3-4b29-a14c-28ddafd1f813",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:17.134002Z",
+     "iopub.status.busy": "2024-05-16T16:38:17.133785Z",
+     "iopub.status.idle": "2024-05-16T16:38:17.147051Z",
+     "shell.execute_reply": "2024-05-16T16:38:17.146431Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:17.133987Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# cmd_list = []\n",
+    "# outpath = \"~/lsst-adler/logging\"\n",
+    "# cmd = \"adler -s {} -f {} -o {}\".format(ssoid2,filt,outpath)\n",
+    "\n",
+    "# for t0 in data_nights:\n",
+    "#     t1 = t0+1\n",
+    "\n",
+    "#     mask = (df_obs[\"midPointMjdTai\"]<t1)\n",
+    "#     _df_obs = df_obs[mask]\n",
+    "#     # print(t0,t1, len(_df_obs))\n",
+    "#     _cmd = cmd + \" -i {} -d {} {}\".format(fname, tmin,t1)\n",
+    "#     print(_cmd)\n",
+    "#     cmd_list.append(_cmd)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9f28a60a-dbec-4320-9150-f36ed75d4ffa",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:17.148063Z",
+     "iopub.status.busy": "2024-05-16T16:38:17.147855Z",
+     "iopub.status.idle": "2024-05-16T16:38:17.161783Z",
+     "shell.execute_reply": "2024-05-16T16:38:17.161131Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:17.148049Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# cmd_file = \"../adler_demo_cli/adler_{}.sh\".format(ssoid2)\n",
+    "# with open(cmd_file,\"w\") as f:\n",
+    "#     f.write(\"#!/usr/bin/env bash\\n\")\n",
+    "#     f.write(\"\\n\".join(cmd_list))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "574b7fb2-54db-4797-9d00-330964ed6bb9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:17.165476Z",
+     "iopub.status.busy": "2024-05-16T16:38:17.165252Z",
+     "iopub.status.idle": "2024-05-16T16:38:17.176989Z",
+     "shell.execute_reply": "2024-05-16T16:38:17.176390Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:17.165460Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# using the adler api, search for outliers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c285a1ee-a168-45ec-8c10-e82774230979",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:17.178422Z",
+     "iopub.status.busy": "2024-05-16T16:38:17.177953Z",
+     "iopub.status.idle": "2024-05-16T16:38:49.153683Z",
+     "shell.execute_reply": "2024-05-16T16:38:49.153052Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:17.178403Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "N_pc_fit = 10\n",
+    "diff_cut = 1.0\n",
+    "filt = \"r\"\n",
+    "\n",
+    "# get the filter SSObject metadata\n",
+    "sso = planetoid2.SSObject_in_filter(filt)\n",
+    "\n",
+    "# get the observations\n",
+    "obs = planetoid2.observations_in_filter(filt)\n",
+    "df_obs = pd.DataFrame(obs.__dict__)\n",
+    "\n",
+    "# get the LSST phase curve filter model\n",
+    "pc = PhaseCurve(\n",
+    "    abs_mag=sso.H * u.mag,\n",
+    "    phase_param=0.62,\n",
+    "    model_name=\"HG12_Pen16\",\n",
+    ")\n",
+    "\n",
+    "j = 0\n",
+    "for i, t0 in enumerate(data_nights):\n",
+    "    t1 = t0 + 1\n",
+    "\n",
+    "    # load the df_obs outlier column here\n",
+    "    outlier_file_load = \"data/outlier_{}_{}.npy\".format(ssoid2, int(data_nights[i - 1]))\n",
+    "    outlier_file_save = \"data/outlier_{}_{}\".format(ssoid2, int(t0))\n",
+    "    if j == 0:\n",
+    "        outliers = [False] * len(df_obs)\n",
+    "    else:\n",
+    "        outliers = np.load(outlier_file_load)\n",
+    "    df_obs[\"outlier\"] = outliers\n",
+    "\n",
+    "    t_mask = df_obs[\"midPointMjdTai\"] < t1\n",
+    "    _df_obs = df_obs[t_mask]\n",
+    "    mask = _df_obs[\"midPointMjdTai\"] < t0\n",
+    "    df_obs_old = _df_obs[(mask) & (_df_obs[\"outlier\"] == False)]\n",
+    "    df_obs_new = _df_obs[~mask]\n",
+    "\n",
+    "    if len(df_obs_old) < 2:\n",
+    "        print(\"continue\")\n",
+    "        continue\n",
+    "    else:\n",
+    "        j = 1\n",
+    "\n",
+    "    if len(df_obs_old) < N_pc_fit:\n",
+    "        # use an assumed value of G12 until more data is available\n",
+    "        pc.model_function.G12.fixed = True\n",
+    "    else:\n",
+    "        pc.model_function.G12.fixed = False\n",
+    "\n",
+    "    # do a simple HG12_Pen16 fit to the past data\n",
+    "    pc_fit = pc.FitModel(\n",
+    "        np.array(df_obs_old[\"phaseAngle\"]) * u.deg,\n",
+    "        np.array(df_obs_old[\"reduced_mag\"]) * u.mag,\n",
+    "        np.array(df_obs_old[\"magErr\"]) * u.mag,\n",
+    "    )\n",
+    "    pc_fit = pc.InitModelSbpy(pc_fit)\n",
+    "\n",
+    "    print(t0, t1, len(df_obs_old), len(df_obs_new), pc_fit.model_function.H, pc_fit.model_function.G12)\n",
+    "\n",
+    "    # find outliers in new data\n",
+    "    # calculate data - model residuals\n",
+    "    res = (np.array(df_obs_new[\"reduced_mag\"]) * u.mag) - pc_fit.ReducedMag(\n",
+    "        np.array(df_obs_new[\"phaseAngle\"]) * u.deg\n",
+    "    )\n",
+    "\n",
+    "    outlier_flag = sci_utils.outlier_diff(res.value, diff_cut=diff_cut)\n",
+    "    print(outlier_flag)\n",
+    "\n",
+    "    df_obs.loc[(t_mask & ~mask), \"outlier\"] = outlier_flag\n",
+    "\n",
+    "    # save the df_obs outlier column, in reality it would have been saved as part of AdlerData on the server\n",
+    "    print(\"save {}\".format(outlier_file_save))\n",
+    "    np.save(outlier_file_save, np.array(df_obs[\"outlier\"]))\n",
+    "\n",
+    "    # make a plot\n",
+    "    fig = plot_errorbar(planetoid2, filt_list=[])\n",
+    "    ax1 = fig.axes[0]\n",
+    "    ax1.scatter(df_obs_old[\"phaseAngle\"], df_obs_old[\"reduced_mag\"], c=\"C0\")\n",
+    "    alpha = np.linspace(0, np.amax(obs.phaseAngle)) * u.deg\n",
+    "    ax1.plot(alpha.value, pc_fit.ReducedMag(alpha).value, label=\"t={}\".format(int(t0)))\n",
+    "    ax1.scatter(\n",
+    "        df_obs_new[\"phaseAngle\"], df_obs_new[\"reduced_mag\"], edgecolor=\"r\", facecolor=\"none\", zorder=3\n",
+    "    )\n",
+    "\n",
+    "    # ax1.scatter(df_obs_new.loc[outlier_flag][\"phaseAngle\"], df_obs_new.loc[outlier_flag][\"reduced_mag\"], c = \"r\", marker = \"x\", s= 75, zorder = 3)\n",
+    "    out_mask = df_obs[\"outlier\"] == True\n",
+    "    ax1.scatter(\n",
+    "        df_obs.loc[out_mask][\"phaseAngle\"],\n",
+    "        df_obs.loc[out_mask][\"reduced_mag\"],\n",
+    "        c=\"r\",\n",
+    "        marker=\"x\",\n",
+    "        s=75,\n",
+    "        zorder=3,\n",
+    "    )\n",
+    "    fig_file = \"plots/phase_curve_{}_{}.png\".format(ssoid2, int(t0))\n",
+    "    print(fig_file)\n",
+    "    fig = plot_errorbar(planetoid2, fig=fig, filename=fig_file)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fa32a24b-930f-4bf6-8d82-85a4a039783b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T16:38:49.154920Z",
+     "iopub.status.busy": "2024-05-16T16:38:49.154677Z",
+     "iopub.status.idle": "2024-05-16T16:38:49.170070Z",
+     "shell.execute_reply": "2024-05-16T16:38:49.169497Z",
+     "shell.execute_reply.started": "2024-05-16T16:38:49.154903Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "df_obs[df_obs[\"outlier\"] == True]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac78d242-bf3b-496a-b848-733bf961e3d9",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "adler-dev",
+   "language": "python",
+   "name": "adler-dev"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/gen_test_data/adler_demo_testing_database.db b/notebooks/gen_test_data/adler_demo_testing_database.db
new file mode 100644
index 0000000..1c3cdb5
Binary files /dev/null and b/notebooks/gen_test_data/adler_demo_testing_database.db differ
diff --git a/notebooks/gen_test_data/get_test_data.ipynb b/notebooks/gen_test_data/get_test_data.ipynb
new file mode 100644
index 0000000..887faa9
--- /dev/null
+++ b/notebooks/gen_test_data/get_test_data.ipynb
@@ -0,0 +1,952 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89353ba3-fef0-4e44-b5a7-cf84e8895e38",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:14.755360Z",
+     "iopub.status.busy": "2024-05-16T15:51:14.755141Z",
+     "iopub.status.idle": "2024-05-16T15:51:15.288200Z",
+     "shell.execute_reply": "2024-05-16T15:51:15.287602Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:14.755334Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from lsst.rsp import get_tap_service\n",
+    "import sqlite3\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c8c661de-721c-4a8a-8950-d94a64a7e351",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:15.289420Z",
+     "iopub.status.busy": "2024-05-16T15:51:15.289027Z",
+     "iopub.status.idle": "2024-05-16T15:51:15.344750Z",
+     "shell.execute_reply": "2024-05-16T15:51:15.343937Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:15.289402Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "service = get_tap_service(\"ssotap\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0780edfd-b9a8-4d07-b12a-0fcc427661ef",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:15.346184Z",
+     "iopub.status.busy": "2024-05-16T15:51:15.345875Z",
+     "iopub.status.idle": "2024-05-16T15:51:15.349520Z",
+     "shell.execute_reply": "2024-05-16T15:51:15.348883Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:15.346166Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "db_fname = \"adler_demo_testing_database.db\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "43ed6219-d23f-4d84-9aa4-68420d43405a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:15.350467Z",
+     "iopub.status.busy": "2024-05-16T15:51:15.350275Z",
+     "iopub.status.idle": "2024-05-16T15:51:15.379422Z",
+     "shell.execute_reply": "2024-05-16T15:51:15.378648Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:15.350451Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "cnx = sqlite3.connect(db_fname)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "816d8725-8cab-4f3b-b6e5-35cd2d85dc3a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:15.381062Z",
+     "iopub.status.busy": "2024-05-16T15:51:15.380759Z",
+     "iopub.status.idle": "2024-05-16T15:51:15.391441Z",
+     "shell.execute_reply": "2024-05-16T15:51:15.390831Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:15.381043Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# ssoid = 8268570668335894776\n",
+    "ssoid_list = (8268570668335894776, 2150553186630, 3369984299447, 5992863104062, 6098332225018)\n",
+    "\n",
+    "test_id = 6098332225018\n",
+    "fake_id = 6098332225018000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "24611019-4132-4c2b-9bef-f7253dd8b55e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:15.392395Z",
+     "iopub.status.busy": "2024-05-16T15:51:15.392197Z",
+     "iopub.status.idle": "2024-05-16T15:51:15.404246Z",
+     "shell.execute_reply": "2024-05-16T15:51:15.403608Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:15.392379Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "filter_name = \"r\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c596e3f0-7575-4aba-9b99-9f0a9ff953a5",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:15.405208Z",
+     "iopub.status.busy": "2024-05-16T15:51:15.405018Z",
+     "iopub.status.idle": "2024-05-16T15:51:15.417036Z",
+     "shell.execute_reply": "2024-05-16T15:51:15.416439Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:15.405193Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# diasource_sql_query = f\"\"\"\n",
+    "#             SELECT\n",
+    "#                 *\n",
+    "#             FROM\n",
+    "#                 dp03_catalogs_10yr.diaSource\n",
+    "#             WHERE\n",
+    "#                 ssObjectId = {ssoid}\n",
+    "#             \"\"\"\n",
+    "diasource_sql_query = f\"\"\"\n",
+    "            SELECT\n",
+    "                *\n",
+    "            FROM\n",
+    "                dp03_catalogs_10yr.diaSource\n",
+    "            WHERE\n",
+    "                ssObjectId in {ssoid_list}\n",
+    "            \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "641b82a5-3ffc-44fd-803a-e658a226a92d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:15.418000Z",
+     "iopub.status.busy": "2024-05-16T15:51:15.417808Z",
+     "iopub.status.idle": "2024-05-16T15:51:16.515888Z",
+     "shell.execute_reply": "2024-05-16T15:51:16.515113Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:15.417985Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "diatable = service.search(diasource_sql_query).to_table().to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fbe7b23f-2061-4f39-aefb-34c5b53af238",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:16.517125Z",
+     "iopub.status.busy": "2024-05-16T15:51:16.516895Z",
+     "iopub.status.idle": "2024-05-16T15:51:16.520739Z",
+     "shell.execute_reply": "2024-05-16T15:51:16.520007Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:16.517107Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# sssource_sql_query = f\"\"\"\n",
+    "#             SELECT\n",
+    "#                 *\n",
+    "#             FROM\n",
+    "#                 dp03_catalogs_10yr.SSSource\n",
+    "#             WHERE\n",
+    "#                 ssObjectId = {ssoid}\n",
+    "#             \"\"\"\n",
+    "sssource_sql_query = f\"\"\"\n",
+    "            SELECT\n",
+    "                *\n",
+    "            FROM\n",
+    "                dp03_catalogs_10yr.SSSource\n",
+    "            WHERE\n",
+    "                ssObjectId in {ssoid_list}\n",
+    "            \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0421e5a7-44d2-4955-8880-d8f009f18bb7",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:16.521766Z",
+     "iopub.status.busy": "2024-05-16T15:51:16.521540Z",
+     "iopub.status.idle": "2024-05-16T15:51:16.830882Z",
+     "shell.execute_reply": "2024-05-16T15:51:16.830256Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:16.521750Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "sssource_table = service.search(sssource_sql_query).to_table().to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "64e8ae53-a487-4a0c-a6da-3dd4574dc6ca",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:16.831911Z",
+     "iopub.status.busy": "2024-05-16T15:51:16.831706Z",
+     "iopub.status.idle": "2024-05-16T15:51:16.836035Z",
+     "shell.execute_reply": "2024-05-16T15:51:16.835562Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:16.831896Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "sssource_table.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "874e3fab-d89e-42ba-8ccd-adefef1ee2d6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:16.836891Z",
+     "iopub.status.busy": "2024-05-16T15:51:16.836665Z",
+     "iopub.status.idle": "2024-05-16T15:51:16.848402Z",
+     "shell.execute_reply": "2024-05-16T15:51:16.847922Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:16.836874Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# ssobject_sql_query = f\"\"\"\n",
+    "#             SELECT\n",
+    "#                 *\n",
+    "#             FROM\n",
+    "#                 dp03_catalogs_10yr.SSObject\n",
+    "#             WHERE\n",
+    "#                 ssObjectId = {ssoid}\n",
+    "#             \"\"\"\n",
+    "ssobject_sql_query = f\"\"\"\n",
+    "            SELECT\n",
+    "                *\n",
+    "            FROM\n",
+    "                dp03_catalogs_10yr.SSObject\n",
+    "            WHERE\n",
+    "                ssObjectId in {ssoid_list}\n",
+    "            \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fb1935bf-71ba-41b7-a19f-0be50ccfa48c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:16.849227Z",
+     "iopub.status.busy": "2024-05-16T15:51:16.849049Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.030419Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.029797Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:16.849213Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ssobject_table = service.search(ssobject_sql_query).to_table().to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dac407b7-b86a-44cf-99d4-de8bc7e4a70f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.031516Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.031246Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.035610Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.035127Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.031499Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ssobject_table.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e6c8b5ed-cd14-4e7c-a0f0-39d2b628d224",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.036469Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.036288Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.050233Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.049633Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.036455Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "ssobject_table[\"r_Ndata\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ec6419b0-64d0-4056-9579-65085b35fa17",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.051356Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.050979Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.062716Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.062172Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.051339Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# mpcorb_sql_query = f\"\"\"\n",
+    "#             SELECT\n",
+    "#                 *\n",
+    "#             FROM\n",
+    "#                 dp03_catalogs_10yr.MPCORB\n",
+    "#             WHERE\n",
+    "#                 ssObjectId = {ssoid}\n",
+    "#             \"\"\"\n",
+    "mpcorb_sql_query = f\"\"\"\n",
+    "            SELECT\n",
+    "                *\n",
+    "            FROM\n",
+    "                dp03_catalogs_10yr.MPCORB\n",
+    "            WHERE\n",
+    "                ssObjectId in {ssoid_list}\n",
+    "            \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "51e6994a-88ed-4b92-ba03-56aba4ec8066",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.063608Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.063397Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.233428Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.232820Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.063570Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "mpcorb_table = service.search(mpcorb_sql_query).to_table().to_pandas()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c356b4b3-5da8-417c-93b4-106ee0899e6f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.234396Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.234208Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.253335Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.252826Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.234380Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "mpcorb_table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "03a065dd-099c-4913-a9ca-5590e1c26534",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.254349Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.254159Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.257129Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.256504Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.254335Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# add a new fake object"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8e182829-078d-42d6-af0f-27e1e071aa5b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.261486Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.261304Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.286690Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.286201Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.261472Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "diatable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7753f35c-870e-465f-b40b-76405853bff6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.287883Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.287546Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.299875Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.299345Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.287862Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "diatable[(diatable[\"ssObjectId\"] == test_id)].value_counts(\"diaSourceId\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a75c4bea-1054-45db-b5f6-8a2993092b86",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.300710Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.300509Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.312925Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.312445Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.300696Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "diatable[(diatable[\"ssObjectId\"] == test_id) & (diatable[\"band\"] == \"r\")].value_counts(\"diaSourceId\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "56b4b04a-3b22-4092-95a9-49aaa5c1d1ed",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.313863Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.313686Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.327018Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.326449Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.313849Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# df_dict = {\"dia\":diatable,\n",
+    "#            \"sss\":sssource_table,\n",
+    "#            \"sso\":ssobject_table,\n",
+    "#            \"mpc\":mpcorb_table}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "37bc252d-c1f3-47d8-97c2-3a19ca34b0f3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.327817Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.327650Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.340474Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.339974Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.327804Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# for x in df_dict:\n",
+    "\n",
+    "#     _df = df_dict[x].copy()[df_dict[x][\"ssObjectId\"]==test_id]\n",
+    "#     _df[\"ssObjectId\"] = fake_id\n",
+    "#     df_dict[x] = pd.concat([df_dict[x],_df],axis = 0).reset_index(drop=True)\n",
+    "#     print(len(_df),len(df_dict[x]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bf5045bb-2a7b-4d63-b5f3-1caeaf3c01f5",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.341321Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.341144Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.353407Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.352881Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.341308Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# diatable = df_dict[\"dia\"]\n",
+    "# sssource_table = df_dict[\"sss\"]\n",
+    "# ssobject_table = df_dict[\"sso\"]\n",
+    "# mpcorb_table = df_dict[\"mpc\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e1a1bdd-1b94-4225-bc95-b383233b6c2d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.354214Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.354045Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.366070Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.365497Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.354201Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# _df = diatable.copy()[diatable[\"ssObjectId\"]==test_id]\n",
+    "# _df[\"ssObjectId\"] = fake_id\n",
+    "# diatable = pd.concat([diatable,_df],axis = 0).reset_index(drop=True)\n",
+    "# # print(len(_df),len(df_dict[x]))\n",
+    "# _df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26b6974b-ff98-4f4e-ab49-352a48ba895a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.366988Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.366751Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.380019Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.379486Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.366974Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# # add an outburst\n",
+    "# t0 = 63100\n",
+    "# t1 = 63600\n",
+    "# mag_shift = -1.5\n",
+    "\n",
+    "# mask = ((diatable[\"ssObjectId\"] == fake_id) &\n",
+    "#         (diatable[\"midPointMjdTai\"] > t0) &\n",
+    "#         (diatable[\"midPointMjdTai\"] < t1))\n",
+    "\n",
+    "# diatable.loc[mask,\"mag\"] += mag_shift"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0433626a-057a-45c2-8cd1-68f3de4022b6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.380986Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.380732Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.410063Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.409487Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.380971Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "diatable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4a41ba6-b8bc-4a24-9e6d-e69d0dc19866",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.411036Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.410846Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.496166Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.495588Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.411022Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# diatable.to_sql(\"diaSource\", con=cnx, if_exists=\"append\", index=False)\n",
+    "diatable.to_sql(\"diaSource\", con=cnx, if_exists=\"replace\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aaab53fe-5391-42f4-9458-c80f8201626f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.497155Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.496952Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.566910Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.566241Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.497140Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# sssource_table.to_sql(\"ssSource\", con=cnx, if_exists=\"append\", index=False)\n",
+    "sssource_table.to_sql(\"ssSource\", con=cnx, if_exists=\"replace\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "00e59db2-d3d5-47ba-b166-e9baa38a18ca",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.567972Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.567727Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.620969Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.620385Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.567954Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# ssobject_table.to_sql(\"ssObject\", con=cnx, if_exists=\"append\", index=False)\n",
+    "ssobject_table.to_sql(\"ssObject\", con=cnx, if_exists=\"replace\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2ef861b6-a2f7-48d3-9494-775525288635",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.621931Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.621730Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.670994Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.670462Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.621916Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# mpcorb_table.to_sql(\"MPCORB\", con=cnx, if_exists=\"append\", index=False)\n",
+    "mpcorb_table.to_sql(\"MPCORB\", con=cnx, if_exists=\"replace\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dbef0ea3-614e-46f1-9ef6-dd8373fe51c6",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.671900Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.671714Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.703052Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.702557Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.671885Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "_diatable = diatable.copy()[diatable[\"ssObjectId\"] == test_id]\n",
+    "_diatable[\"ssObjectId\"] = fake_id\n",
+    "_diatable[\"diaSourceId\"] = _diatable[\"diaSourceId\"] * 1000\n",
+    "\n",
+    "# add an outburst\n",
+    "t0 = 63100\n",
+    "t1 = 63600\n",
+    "mag_shift = -1.5\n",
+    "\n",
+    "mask = (\n",
+    "    (_diatable[\"ssObjectId\"] == fake_id)\n",
+    "    & (_diatable[\"midPointMjdTai\"] > t0)\n",
+    "    & (_diatable[\"midPointMjdTai\"] < t1)\n",
+    ")\n",
+    "\n",
+    "_diatable.loc[mask, \"mag\"] += mag_shift\n",
+    "\n",
+    "_diatable.to_sql(\"diaSource\", con=cnx, if_exists=\"append\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e3bb4edd-844f-436c-acec-cf75075a216e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.703989Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.703796Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.724554Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.724027Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.703975Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "_diatable[diatable[\"band\"] == \"r\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53f27516-1c24-4567-b1f6-11b93cde07e8",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.725408Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.725225Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.788111Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.787591Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.725393Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "_sssource_table = sssource_table.copy()[sssource_table[\"ssObjectId\"] == test_id]\n",
+    "_sssource_table[\"ssObjectId\"] = fake_id\n",
+    "_sssource_table[\"diaSourceId\"] = _sssource_table[\"diaSourceId\"] * 1000\n",
+    "_sssource_table.to_sql(\"ssSource\", con=cnx, if_exists=\"append\", index=False)\n",
+    "\n",
+    "_ssobject_table = ssobject_table.copy()[ssobject_table[\"ssObjectId\"] == test_id]\n",
+    "_ssobject_table[\"ssObjectId\"] = fake_id\n",
+    "_ssobject_table.to_sql(\"ssObject\", con=cnx, if_exists=\"append\", index=False)\n",
+    "\n",
+    "_mpcorb_table = mpcorb_table.copy()[mpcorb_table[\"ssObjectId\"] == test_id]\n",
+    "_mpcorb_table[\"ssObjectId\"] = fake_id\n",
+    "_mpcorb_table.to_sql(\"MPCORB\", con=cnx, if_exists=\"append\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5935a89f-ddae-4587-9546-0dce6f91789c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.788992Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.788810Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.792091Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.791606Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.788978Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "cnx.close()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b62d7ab4-3ee7-46b2-9d30-f0b740c88068",
+   "metadata": {},
+   "source": [
+    "Testing everything went correctly..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a53c503-3a1a-44f3-b8c2-0aa5dde7a397",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.792894Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.792718Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.804834Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.804254Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.792880Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "cnx = sqlite3.connect(db_fname)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "06b38c09-3fe4-4eb9-811b-37a97052b0c8",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.805587Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.805408Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.816695Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.816120Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.805560Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# example_query = f\"\"\"\n",
+    "#                 SELECT\n",
+    "#                     ssObject.ssObjectId, mag, magErr, band, midpointMjdTai, ra, dec, phaseAngle,\n",
+    "#                     topocentricDist, heliocentricDist\n",
+    "#                 FROM\n",
+    "#                     ssObject\n",
+    "#                     JOIN diaSource ON ssObject.ssObjectId   = diaSource.ssObjectId\n",
+    "#                     JOIN ssSource  ON diaSource.diaSourceId = ssSource.diaSourceId\n",
+    "#                 WHERE\n",
+    "#                     ssObject.ssObjectId = {ssoid}\n",
+    "#                 \"\"\"\n",
+    "# example_query = f\"\"\"\n",
+    "#                 SELECT\n",
+    "#                     ssObject.ssObjectId, mag, magErr, band, midpointMjdTai, ra, dec, phaseAngle,\n",
+    "#                     topocentricDist, heliocentricDist\n",
+    "#                 FROM\n",
+    "#                     ssObject\n",
+    "#                     JOIN diaSource ON ssObject.ssObjectId   = diaSource.ssObjectId\n",
+    "#                     JOIN ssSource  ON diaSource.diaSourceId = ssSource.diaSourceId\n",
+    "#                 WHERE\n",
+    "#                     ssObject.ssObjectId in {ssoid_list}\n",
+    "#                 \"\"\"\n",
+    "\n",
+    "example_query = f\"\"\"\n",
+    "                SELECT\n",
+    "                    ssObject.ssObjectId, ssSource.diaSourceId, mag, magErr, band, midpointMjdTai, ra, dec, phaseAngle,\n",
+    "                    topocentricDist, heliocentricDist\n",
+    "                FROM\n",
+    "                    ssObject\n",
+    "                    JOIN diaSource ON ssObject.ssObjectId   = diaSource.ssObjectId\n",
+    "                    JOIN ssSource  ON diaSource.diaSourceId = ssSource.diaSourceId\n",
+    "                WHERE\n",
+    "                    ssObject.ssObjectId = {fake_id} and band = 'r'\n",
+    "                \"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53b44a8b-0aed-4d90-8397-aed7c6ba4514",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.817506Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.817322Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.849053Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.848475Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.817493Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "pd.read_sql_query(example_query, cnx)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90d6c5fc-4848-4d4f-84c7-5f247f08de7d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.849938Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.849750Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.852669Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.852185Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.849924Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "cur = cnx.cursor()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e8d59efa-1e98-4cd2-9e1a-3609df99934b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.853526Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.853344Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.867448Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.866908Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.853512Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "res = cur.execute(\"SELECT * FROM sqlite_schema\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c087e1b-8bfe-4572-accf-49585a6a08a1",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-05-16T15:51:17.868644Z",
+     "iopub.status.busy": "2024-05-16T15:51:17.868421Z",
+     "iopub.status.idle": "2024-05-16T15:51:17.880840Z",
+     "shell.execute_reply": "2024-05-16T15:51:17.880300Z",
+     "shell.execute_reply.started": "2024-05-16T15:51:17.868629Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "res.fetchall()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d6da55b0-dc55-4762-8735-c5531fdcef9c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "LSST",
+   "language": "python",
+   "name": "lsst"
+  },
+  "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.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/adler/adler.py b/src/adler/adler.py
index b167466..2987cc6 100644
--- a/src/adler/adler.py
+++ b/src/adler/adler.py
@@ -1,12 +1,17 @@
 import logging
 import argparse
 import astropy.units as u
+import numpy as np
+import pandas as pd
+import os
 
 from adler.dataclasses.AdlerPlanetoid import AdlerPlanetoid
 from adler.science.PhaseCurve import PhaseCurve
 from adler.utilities.AdlerCLIArguments import AdlerCLIArguments
 from adler.utilities.adler_logging import setup_adler_logging
 from adler.utilities.readin_utilities import read_in_SSObjectID_file
+from adler.utilities.plotting_utilities import plot_errorbar
+import adler.utilities.science_utilities as sci_utils
 
 logger = logging.getLogger(__name__)
 
@@ -14,6 +19,9 @@
 def runAdler(cli_args):
     logger.info("Beginning Adler.")
 
+    N_pc_fit = 10  # minimum number of data points to fit phase curve
+    diff_cut = 1.0
+
     if cli_args.ssObjectId_list:
         ssObjectId_list = read_in_SSObjectID_file(cli_args.ssObjectId_list)
     else:
@@ -23,34 +31,168 @@ def runAdler(cli_args):
         logger.info("Processing object {}/{}.".format(i + 1, len(ssObjectId_list)))
         logger.info("Ingesting all data for object {} from RSP...".format(cli_args.ssObjectId))
 
-        planetoid = AdlerPlanetoid.construct_from_RSP(ssObjectId, cli_args.filter_list, cli_args.date_range)
+        # if cli_args.sql_filename != "None":
+        if cli_args.sql_filename:
+            msg = "query sql database {}".format(cli_args.sql_filename)
+            logger.info(msg)
+            print(msg)
+            planetoid = AdlerPlanetoid.construct_from_SQL(
+                ssObjectId,
+                filter_list=cli_args.filter_list,
+                date_range=cli_args.date_range,
+                sql_filename=cli_args.sql_filename,
+            )
+        else:
+            msg = "query RSP"
+            logger.info(msg)
+            print(msg)
+            planetoid = AdlerPlanetoid.construct_from_RSP(
+                ssObjectId, cli_args.filter_list, cli_args.date_range
+            )
 
         logger.info("Data successfully ingested.")
         logger.info("Calculating phase curves...")
 
         # now let's do some phase curves!
 
-        # get the r filter SSObject metadata
-        sso_r = planetoid.SSObject_in_filter("r")
+        # # operate on each filter in turn
+        for filt in planetoid.filter_list:
+            print("fit {} filter data".format(filt))
+
+            # get the filter SSObject metadata
+            sso = planetoid.SSObject_in_filter(filt)
+
+            # get the observations
+            obs = planetoid.observations_in_filter(filt)
+            df_obs = pd.DataFrame(obs.__dict__)
+            df_obs["outlier"] = [False] * len(df_obs)
+            print(len(df_obs))
+
+            # load and merge the previous obs
+            save_file = "{}/df_outlier_{}.csv".format(cli_args.outpath, cli_args.ssObjectId)
+            if os.path.isfile(save_file):
+                print("load {}".format(save_file))
+                _df_obs = pd.read_csv(save_file, index_col=0)
+                df_obs = df_obs.merge(_df_obs, on="midPointMjdTai", how="left")
+                df_obs = df_obs.rename({"outlier_y": "outlier"}, axis=1)
+                df_obs = df_obs.drop("outlier_x", axis=1)
+            else:
+                print("no previous obs to load")
+
+            print(cli_args.date_range)
+            print(np.amax(df_obs["midPointMjdTai"]))
+            t1 = int(np.amax(df_obs["midPointMjdTai"])) + 1
+            t0 = t1 - 1
+
+            # t_mask = (df_obs["midPointMjdTai"]<t1)
+            # _df_obs = df_obs[t_mask]
+            mask = df_obs["midPointMjdTai"] < t0
+            df_obs_old = df_obs[(mask)]
+            df_obs_new = df_obs[~mask]
+            print(t0, t1, len(df_obs_old), len(df_obs_new))
+
+            if len(df_obs_old) < 2:
+                print("save {}".format(save_file))
+                df_save = df_obs[["midPointMjdTai", "outlier"]]
+                df_save.to_csv(save_file)
+                print("insufficient data, continue")
+                continue
+
+            # initial simple phase curve filter model with fixed G12
+            pc = PhaseCurve(
+                abs_mag=sso.H * u.mag,
+                phase_param=0.62,
+                model_name="HG12_Pen16",
+            )
+
+            if len(df_obs_old) < N_pc_fit:
+                # use an assumed value of G12 until more data is available
+                pc.model_function.G12.fixed = True
+            else:
+                pc.model_function.G12.fixed = False
+
+            # do a simple HG12_Pen16 fit to the past data
+            pc_fit = pc.FitModel(
+                np.array(df_obs_old["phaseAngle"]) * u.deg,
+                np.array(df_obs_old["reduced_mag"]) * u.mag,
+                np.array(df_obs_old["magErr"]) * u.mag,
+            )
+            pc_fit = pc.InitModelSbpy(pc_fit)
+
+            # find outliers in new data
+            # calculate data - model residuals
+            res = (np.array(df_obs_new["reduced_mag"]) * u.mag) - pc_fit.ReducedMag(
+                np.array(df_obs_new["phaseAngle"]) * u.deg
+            )
+            # print(res)
+            outlier_flag = sci_utils.outlier_diff(res.value, diff_cut=diff_cut)
+            print(outlier_flag)
+            df_obs.loc[~mask, "outlier"] = outlier_flag
 
-        # get the RSP r filter model
-        pc = PhaseCurve(
-            abs_mag=sso_r.H * u.mag,
-            phase_param=sso_r.G12,
-            model_name="HG12_Pen16",
-        )
-        print(pc)
-        print(pc.abs_mag, pc.phase_param)
+            # save the df_obs subset
+            df_save = df_obs[["midPointMjdTai", "outlier"]]
+            print("save {}".format(save_file))
+            df_save.to_csv(save_file)
 
-        # get the r filter observations
-        obs_r = planetoid.observations_in_filter("r")
-        alpha = obs_r.phaseAngle * u.deg
-        red_mag = obs_r.reduced_mag * u.mag
-        mag_err = obs_r.magErr * u.mag
+            # make a plot
+            fig = plot_errorbar(planetoid, filt_list=[])
+            ax1 = fig.axes[0]
+            ax1.scatter(df_obs_old["phaseAngle"], df_obs_old["reduced_mag"], c="C0")
+            alpha = np.linspace(0, np.amax(obs.phaseAngle)) * u.deg
+            ax1.plot(alpha.value, pc_fit.ReducedMag(alpha).value, label="t={}".format(int(t0)))
+            ax1.scatter(
+                df_obs_new["phaseAngle"], df_obs_new["reduced_mag"], edgecolor="r", facecolor="none", zorder=3
+            )
+            # ax1.scatter(df_obs_new.loc[outlier_flag]["phaseAngle"], df_obs_new.loc[outlier_flag]["reduced_mag"], c = "r", marker = "x", s= 75, zorder = 3)
+            out_mask = df_obs["outlier"] == True
+            ax1.scatter(
+                df_obs.loc[out_mask]["phaseAngle"],
+                df_obs.loc[out_mask]["reduced_mag"],
+                c="r",
+                marker="x",
+                s=75,
+                zorder=3,
+            )
+            fig_file = "{}/plots/phase_curve_{}_{}.png".format(cli_args.outpath, cli_args.ssObjectId, int(t0))
+            print(fig_file)
+            fig = plot_errorbar(planetoid, fig=fig, filename=fig_file)
 
-        # do a simple fit to all data
-        pc_fit = pc.FitModel(alpha, red_mag, mag_err)
-        print(pc_fit)
+            # # when fitting, consider only the previous observations (not tonight's)
+            # mjd = obs.midPointMjdTai
+            # obs_mask = mjd < int(np.amax(mjd))
+            # # also drop any past outlying observations?
+
+            # print("total N obs = {}".format(len(mjd)))
+            # print("number of past obs = {}".format(sum(obs_mask)))
+            # print("number of tonight's obs = {}".format(sum(~obs_mask)))
+
+            # if sum(obs_mask) < N_pc_fit:
+            #     # use an assumed value of G12 until more data is available
+            #     pc_fit = PhaseCurve(abs_mag=sso.H * u.mag, phase_param=0.62, model_name="HG12_Pen16")
+            # else:
+            #     # do a simple HG12_Pen16 fit to the past data
+            #     pc_fit = pc.FitModel(alpha[obs_mask], red_mag[obs_mask], mag_err[obs_mask])
+            #     pc_fit = pc.InitModelSbpy(pc_fit)
+
+            # print(pc_fit)
+            # print(pc_fit.abs_mag)
+            # print(pc_fit.phase_param)
+
+            # # now check if the new observations are outlying
+            # alpha_new = alpha[~obs_mask]
+            # red_mag_new = red_mag[~obs_mask]
+            # mag_err_new = mag_err[~obs_mask]
+
+            # # calculate data - model residuals
+            # res = red_mag_new - pc_fit.ReducedMag(alpha_new)
+            # print(res)
+
+            # # also check for past observations that are outlying?
+
+            # # output results:
+            # # flag outlying observations
+            # # output the phase curve model parameters
+            # # make a plot?
 
 
 def main():
@@ -98,6 +240,13 @@ def main():
         type=str,
         default="adler_out",
     )
+    optional_group.add_argument(
+        "-i",
+        "--sql_filename",
+        help="Optional input path location of a sql database file containing observations",
+        type=str,
+        default=None,
+    )
 
     args = parser.parse_args()
 
diff --git a/src/adler/science/PhaseCurve.py b/src/adler/science/PhaseCurve.py
index cbc328a..dc53468 100644
--- a/src/adler/science/PhaseCurve.py
+++ b/src/adler/science/PhaseCurve.py
@@ -8,7 +8,7 @@ class PhaseCurve:
     Units - by default no units are set but astropy units can be passed.
     It is up to the user to ensure that units are correct for the relevant phasecurve model.
 
-    Attibutes
+    Attributes
     -----------
     abs_mag : float
        Absolute magnitude, H, of the phasecurve model (often units of mag).
@@ -24,6 +24,9 @@ class PhaseCurve:
        Label for the phasecurve model to be used.
        Choice of: "HG", "HG1G2", "HG12", "HG12_Pen16", "LinearPhaseFunc"
 
+    bounds: bool
+       Flag for using the default bounds on the sbpy model (True) or ignoring bounds (False).
+
     """
 
     def __init__(self, abs_mag=18, phase_param=0.2, phase_param2=None, model_name="HG"):
@@ -45,6 +48,12 @@ def __init__(self, abs_mag=18, phase_param=0.2, phase_param2=None, model_name="H
         else:
             print("no model selected")
 
+    def SetModelBounds(self, param, bound_vals=(None, None)):
+        model_sbpy = self.model_function
+        param_names = model_sbpy.param_names
+        x = getattr(model_sbpy, param)
+        setattr(x, "bounds", bound_vals)
+
     def ReturnModelDict(self):
         """Return the values for the PhaseCurve class as a dict
 
@@ -109,7 +118,7 @@ def InitModelSbpy(self, model_sbpy):
             if x is None:
                 x = getattr(model_sbpy, p).value
             parameters.append(x)
-        print(param_names, parameters)
+        # print(param_names, parameters)
 
         # create a PhaseCurve object with the extracted parameters
         model = PhaseCurve(*parameters, model_name=model_name)
@@ -163,15 +172,15 @@ def FitModel(self, phase_angle, reduced_mag, mag_err=None, fitter=None):
         Returns
         ----------
 
-        return_value : float or array
-           The phasecurve model reduced magnitude at the given phase angle(s)
+        model_fit : object
+           The sbpy phasecurve model object
 
         """
 
         # use the LevMarLSQFitter by default
         if fitter is None:
             fitter = LevMarLSQFitter()
-        print(fitter)
+        # print(fitter)
 
         if mag_err is not None:  # fit weighted by photometric uncertainty
             model_fit = fitter(self.model_function, phase_angle, reduced_mag, weights=1.0 / mag_err)
diff --git a/src/adler/utilities/AdlerCLIArguments.py b/src/adler/utilities/AdlerCLIArguments.py
index 80e0481..e75533b 100644
--- a/src/adler/utilities/AdlerCLIArguments.py
+++ b/src/adler/utilities/AdlerCLIArguments.py
@@ -22,6 +22,7 @@ def __init__(self, args):
         self.date_range = args.date_range
         self.outpath = args.outpath
         self.db_name = args.db_name
+        self.sql_filename = args.sql_filename
 
         self.validate_arguments()
 
diff --git a/src/adler/utilities/science_utilities.py b/src/adler/utilities/science_utilities.py
index c6f965d..68beaf7 100644
--- a/src/adler/utilities/science_utilities.py
+++ b/src/adler/utilities/science_utilities.py
@@ -18,7 +18,7 @@ def outlier_diff(new_res, diff_cut=1.0):
     """
 
     if not isinstance(new_res, np.ndarray):
-        new_res = np.array(new_res)
+        new_res = np.array(new_res, ndmin=1)
 
     outlier_flag = np.array([False] * len(new_res))
     outlier_flag[np.abs(new_res) >= diff_cut] = True
@@ -47,7 +47,7 @@ def outlier_std(new_res, data_res, std_cut=3.0):
     data_std = np.std(data_res)
 
     if not isinstance(new_res, np.ndarray):
-        new_res = np.array(new_res)
+        new_res = np.array(new_res, ndmin=1)
 
     outlier_flag = np.array([False] * len(new_res))
     outlier_flag[np.abs(new_res) >= (data_std * std_cut)] = True
diff --git a/tests/adler/utilities/test_AdlerCLIArguments.py b/tests/adler/utilities/test_AdlerCLIArguments.py
index 372bc83..aed938e 100644
--- a/tests/adler/utilities/test_AdlerCLIArguments.py
+++ b/tests/adler/utilities/test_AdlerCLIArguments.py
@@ -6,13 +6,14 @@
 
 # AdlerCLIArguments object takes an object as input, so we define a quick one here
 class args:
-    def __init__(self, ssObjectId, ssObjectId_list, filter_list, date_range, outpath, db_name):
+    def __init__(self, ssObjectId, ssObjectId_list, filter_list, date_range, outpath, db_name, sql_filename):
         self.ssObjectId = ssObjectId
         self.ssObjectId_list = ssObjectId_list
         self.filter_list = filter_list
         self.date_range = date_range
         self.outpath = outpath
         self.db_name = db_name
+        self.sql_filename = sql_filename
 
 
 def test_AdlerCLIArguments_population():
@@ -24,6 +25,7 @@ def test_AdlerCLIArguments_population():
         "date_range": [60000.0, 67300.0],
         "outpath": "./",
         "db_name": "output",
+        "sql_filename": None,
     }
     good_arguments = args(**good_input_dict)
     good_arguments_object = AdlerCLIArguments(good_arguments)
@@ -39,10 +41,17 @@ def test_AdlerCLIArguments_population():
     good_arguments_object = AdlerCLIArguments(good_arguments)
     assert good_arguments_object.ssObjectId_list == get_test_data_filepath("test_SSOIDs.txt")
 
+    # also test setting sql_filename
+
+    good_input_dict["sql_filename"] = get_test_data_filepath("testing_database.db")
+    good_arguments = args(**good_input_dict)
+    good_arguments_object = AdlerCLIArguments(good_arguments)
+    assert good_arguments_object.sql_filename == get_test_data_filepath("testing_database.db")
+
 
 def test_AdlerCLIArguments_badSSOID():
     # test that a bad ssObjectId triggers the right error
-    bad_ssoid_arguments = args("hello!", None, ["g", "r", "i"], [60000.0, 67300.0], "./", "output")
+    bad_ssoid_arguments = args("hello!", None, ["g", "r", "i"], [60000.0, 67300.0], "./", "output", "None")
 
     with pytest.raises(ValueError) as bad_ssoid_error:
         bad_ssoid_object = AdlerCLIArguments(bad_ssoid_arguments)
@@ -55,7 +64,7 @@ def test_AdlerCLIArguments_badSSOID():
 
 def test_AdlerCLIArguments_badfilters():
     # test that non-LSST or unexpected filters trigger the right error
-    bad_filter_arguments = args("666", None, ["g", "r", "i", "m"], [60000.0, 67300.0], "./", "output")
+    bad_filter_arguments = args("666", None, ["g", "r", "i", "m"], [60000.0, 67300.0], "./", "output", None)
 
     with pytest.raises(ValueError) as bad_filter_error:
         bad_filter_object = AdlerCLIArguments(bad_filter_arguments)
@@ -65,7 +74,7 @@ def test_AdlerCLIArguments_badfilters():
         == "Unexpected filters found in --filter_list command-line argument. --filter_list must be a list of LSST filters."
     )
 
-    bad_filter_arguments_2 = args("666", None, ["pony"], [60000.0, 67300.0], "./", "output")
+    bad_filter_arguments_2 = args("666", None, ["pony"], [60000.0, 67300.0], "./", "output", None)
 
     with pytest.raises(ValueError) as bad_filter_error_2:
         bad_filter_object = AdlerCLIArguments(bad_filter_arguments_2)
@@ -78,7 +87,7 @@ def test_AdlerCLIArguments_badfilters():
 
 def test_AdlerCLIArguments_baddates():
     # test that overly-large dates trigger the right error
-    big_date_arguments = args("666", None, ["g", "r", "i"], [260000.0, 267300.0], "./", "output")
+    big_date_arguments = args("666", None, ["g", "r", "i"], [260000.0, 267300.0], "./", "output", None)
 
     with pytest.raises(ValueError) as big_date_error:
         big_date_object = AdlerCLIArguments(big_date_arguments)
@@ -89,7 +98,7 @@ def test_AdlerCLIArguments_baddates():
     )
 
     # test that unexpected date values trigger the right error
-    bad_date_arguments = args("666", None, ["g", "r", "i"], [60000.0, "cheese"], "./", "output")
+    bad_date_arguments = args("666", None, ["g", "r", "i"], [60000.0, "cheese"], "./", "output", None)
 
     with pytest.raises(ValueError) as bad_date_error:
         bad_date_object = AdlerCLIArguments(bad_date_arguments)
@@ -102,7 +111,7 @@ def test_AdlerCLIArguments_baddates():
 
 def test_AdlerCLIArguments_badoutput():
     bad_output_arguments = args(
-        "666", None, ["g", "r", "i"], [60000.0, 67300.0], "./definitely_fake_folder/", "output"
+        "666", None, ["g", "r", "i"], [60000.0, 67300.0], "./definitely_fake_folder/", "output", None
     )
 
     with pytest.raises(ValueError) as bad_output_error:
@@ -122,6 +131,7 @@ def test_AdlerCLIArguments_badlist():
         [60000.0, 67300.0],
         "./definitely_fake_folder/",
         "output",
+        None,
     )
 
     with pytest.raises(ValueError) as bad_list_error:
diff --git a/tests/adler/utilities/test_science_utilities.py b/tests/adler/utilities/test_science_utilities.py
index 3bee7c9..3a2d753 100644
--- a/tests/adler/utilities/test_science_utilities.py
+++ b/tests/adler/utilities/test_science_utilities.py
@@ -184,6 +184,30 @@ def test_outlier_diff():
     assert_array_equal(outliers, outliers_y)
 
 
+# check that a single value gets processed as a np.array
+def test_outlier_diff_single_val():
+    outliers = sci_utils.outlier_diff(y_res[0], diff_cut=1.0)
+    assert_array_equal(outliers, outliers_y[:1])
+
+
+# check that a list gets processed as a np.array
+def test_outlier_diff_single_val():
+    outliers = sci_utils.outlier_diff(list(y_res[:3]), diff_cut=1.0)
+    assert_array_equal(outliers, outliers_y[:3])
+
+
+# test if a single data point is outlying the std residuals of the previous data points
+def test_outlier_std():
+    outliers = sci_utils.outlier_std(y_res[-8], y_res[:-8])
+    assert_array_equal(outliers, outliers_y[-8])
+
+
+# test the std residual of a list of data points
+def test_outlier_std():
+    outliers = sci_utils.outlier_std(y_res[-8:-5], y_res[:-8])
+    assert_array_equal(outliers, outliers_y[-8:-5])
+
+
 def test_zero_func():
     assert sci_utils.zero_func(y_res) == 0