diff --git a/examples/Tau_Validation.ipynb b/examples/Tau_Validation.ipynb
new file mode 100644
index 000000000..bb4212da0
--- /dev/null
+++ b/examples/Tau_Validation.ipynb
@@ -0,0 +1,814 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('..')\n",
+    "import gillespy2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "import numpy\n",
+    "import scipy.stats\n",
+    "from matplotlib import pyplot as plt\n",
+    "import pickle\n",
+    "import copy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sys.path.append('../test/')\n",
+    "import example_models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_model_names = [\n",
+    " 'create_decay',\n",
+    " 'create_dimerization',\n",
+    " 'create_michaelis_menten',\n",
+    " 'create_toggle_switch',\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Tau Stepsize Convergence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_model_tau_convergence(model, cache):\n",
+    "    #0==auto step size selection\n",
+    "    tau_stepsize_values = [0, 1, 7.5e-1, 5e-1, 3.5e-1, 2e-1, 1e-1, 5e-2, 2.5e-2, 1e-2]  \n",
+    "\n",
+    "    Ntraj=1e3\n",
+    "    tau_solvers = [gillespy2.TauHybridSolver, \n",
+    "                   gillespy2.TauHybridCSolver,\n",
+    "                   gillespy2.TauLeapingSolver,\n",
+    "                   gillespy2.TauLeapingCSolver,\n",
+    "                  ]\n",
+    "    ssa_solvers = [gillespy2.NumPySSASolver, gillespy2.SSACSolver]\n",
+    "    \n",
+    "    # run SSA solvers to show noise floor\n",
+    "    if 0 not in cache:\n",
+    "        cache[0] = {}\n",
+    "    for solver in ssa_solvers:\n",
+    "        if solver.name not in cache[0]:\n",
+    "            cache[0][solver.name] = {}\n",
+    "        for batch in ['A', 'B']:\n",
+    "            if batch in cache[0][solver.name]: \n",
+    "                print(f\"cached  Ntraj={int(Ntraj)} {solver.name} {batch}\")\n",
+    "            else:\n",
+    "                ##\n",
+    "                print(f\"running Ntraj={int(Ntraj)} {solver.name} {batch}\", end='')\n",
+    "                tic = time.time()\n",
+    "                result = model.run(solver=solver, number_of_trajectories=int(Ntraj))\n",
+    "                print(f\"\\t\\tdone in {time.time()-tic}\")\n",
+    "                ##\n",
+    "                a = 0\n",
+    "                b = len(result[0]['time'])\n",
+    "                dist = numpy.zeros((b-a,len(model.listOfSpecies),int(Ntraj)))\n",
+    "                #\n",
+    "                for s_ndx,species in enumerate(model.listOfSpecies):\n",
+    "                    for n_ndx in range(int(Ntraj)):\n",
+    "                        dist[:,s_ndx,n_ndx] = result[n_ndx][species][a:]\n",
+    "                #\n",
+    "                cache[0][solver.name][batch] = dist\n",
+    "\n",
+    "    \n",
+    "    \n",
+    "    ignore_cache_list = [\n",
+    "        #'TauHybridCSolver',\n",
+    "        #'TauHybridSolver',\n",
+    "    ]\n",
+    "    \n",
+    "    # run all the Tau solvers\n",
+    "    for tau_stepsize in tau_stepsize_values:\n",
+    "        tau_stepsize_s=tau_stepsize\n",
+    "        if tau_stepsize==0: tau_stepsize_s='<auto>'\n",
+    "        if tau_stepsize not in cache:\n",
+    "            cache[tau_stepsize] = {}\n",
+    "        for solver in tau_solvers:\n",
+    "            if solver.name in cache[tau_stepsize]:\n",
+    "                if solver.name in ignore_cache_list and tau_stepsize==0:\n",
+    "                    print(f\"cached-rerunning  tau={tau_stepsize_s} {solver.name}\")\n",
+    "                else:\n",
+    "                    print(f\"cached  tau={tau_stepsize_s} {solver.name}\")\n",
+    "                    continue\n",
+    "            ##\n",
+    "            print(f\"running tau={tau_stepsize_s} {solver.name}\", end='')\n",
+    "            mymodel = copy.deepcopy(model)\n",
+    "            print(\"\\n\\t converting all species to 'discrete'\")\n",
+    "            for species in mymodel.listOfSpecies:\n",
+    "                mymodel.listOfSpecies[species].mode='discrete'\n",
+    "\n",
+    "            tic = time.time()\n",
+    "            if tau_stepsize==0:\n",
+    "                sol_obj = solver(model=mymodel)\n",
+    "            else:\n",
+    "                sol_obj = solver(model=mymodel, constant_tau_stepsize=tau_stepsize)\n",
+    "            result = sol_obj.run(number_of_trajectories=int(Ntraj))\n",
+    "            print(f\"\\t\\tdone in {time.time()-tic}\")\n",
+    "            ##\n",
+    "            a = 0\n",
+    "            b = len(result[0]['time'])\n",
+    "            dist = numpy.zeros((b-a,len(mymodel.listOfSpecies),int(Ntraj)))\n",
+    "            #\n",
+    "            for s_ndx,species in enumerate(mymodel.listOfSpecies):\n",
+    "                for n_ndx in range(int(Ntraj)):\n",
+    "                    dist[:,s_ndx,n_ndx] = result[n_ndx][species][a:]\n",
+    "            #\n",
+    "            cache[tau_stepsize][solver.name] = dist\n",
+    "                \n",
+    "    \n",
+    "    ############################################################\n",
+    "    def __analyze_full(data1,data2):\n",
+    "        out_arr = numpy.zeros((len(model.listOfSpecies),data1.shape[0]))\n",
+    "        for s_ndx,species in enumerate(model.listOfSpecies):\n",
+    "            for t_ndx in range(data1.shape[0]):\n",
+    "                out_arr[s_ndx,t_ndx] = scipy.stats.ks_2samp(\n",
+    "                            data1[t_ndx,s_ndx,:], \n",
+    "                            data2[t_ndx,s_ndx,:]\n",
+    "                                    ).statistic\n",
+    "        return out_arr\n",
+    "    def __analyze_one(data1,data2):\n",
+    "        d_sum = 0\n",
+    "        d_ssum = 0\n",
+    "        d_cnt = 0\n",
+    "        for s_ndx,species in enumerate(model.listOfSpecies):\n",
+    "            for t_ndx in range(data1.shape[0]):\n",
+    "                d_cnt += 1\n",
+    "                val = scipy.stats.ks_2samp(\n",
+    "                            data1[t_ndx,s_ndx,:], \n",
+    "                            data2[t_ndx,s_ndx,:]\n",
+    "                                    ).statistic\n",
+    "                d_sum += val\n",
+    "                d_ssum += val*val\n",
+    "        mu = d_sum/d_cnt\n",
+    "        sigma = d_ssum/d_cnt - (mu*mu)\n",
+    "        return (mu, sigma)\n",
+    "    \n",
+    "    def __analyze_all_tau(solver_name):\n",
+    "        x_vals = sorted(tau_stepsize_values)\n",
+    "        y_vals = numpy.zeros(len(x_vals))\n",
+    "        y_errs = numpy.zeros(len(x_vals))\n",
+    "        for y_ndx,tau_stepsize in enumerate(x_vals):\n",
+    "            (y_vals[y_ndx],y_errs[y_ndx]) = __analyze_one(\n",
+    "                        cache[0]['NumPySSASolver']['A'],\n",
+    "                        cache[tau_stepsize][solver_name]\n",
+    "                    )\n",
+    "        err_full = __analyze_full(\n",
+    "                    cache[0]['NumPySSASolver']['A'],\n",
+    "                    cache[0][solver_name]\n",
+    "                )\n",
+    "        return (x_vals, y_vals, y_errs, err_full)\n",
+    "    ############################################################\n",
+    "    # Analyze results\n",
+    "    tau_convergence_results_analysis={}\n",
+    "\n",
+    "    print(\"Analyzing: NumPySSASolver-self\")\n",
+    "    tau_convergence_results_analysis['NumPySSASolver-self'] = __analyze_one(\n",
+    "            cache[0]['NumPySSASolver']['A'],\n",
+    "            cache[0]['NumPySSASolver']['B']\n",
+    "        )\n",
+    "    \n",
+    "    print(\"Analyzing: SSACSolver-self\")\n",
+    "    tau_convergence_results_analysis['SSACSolver-self'] = __analyze_one(\n",
+    "            cache[0]['SSACSolver']['A'],\n",
+    "            cache[0]['SSACSolver']['B']\n",
+    "        )\n",
+    "    \n",
+    "    print(\"Analyzing: NumPySSASolver-SSACSolver\")\n",
+    "    tau_convergence_results_analysis['NumPySSASolver-SSACSolver'] = __analyze_one(\n",
+    "            cache[0]['NumPySSASolver']['A'],\n",
+    "            cache[0]['SSACSolver']['A']\n",
+    "        )\n",
+    "    \n",
+    "    \n",
+    "    print(\"Analyzing: TauHybridSolver-NumPySSASolver\")\n",
+    "    tau_convergence_results_analysis['TauHybridSolver-NumPySSASolver'] = __analyze_all_tau('TauHybridSolver')\n",
+    "    \n",
+    "    print(\"Analyzing: TauHybridCSolver-NumPySSASolver\")\n",
+    "    tau_convergence_results_analysis['TauHybridCSolver-NumPySSASolver'] = __analyze_all_tau('TauHybridCSolver')\n",
+    "\n",
+    "    print(\"Analyzing: TauLeapingSolver-NumPySSASolver\")\n",
+    "    tau_convergence_results_analysis['TauLeapingSolver-NumPySSASolver'] = __analyze_all_tau('TauLeapingSolver')\n",
+    "\n",
+    "    print(\"Analyzing: TauLeapingCSolver-NumPySSASolver\")\n",
+    "    tau_convergence_results_analysis['TauLeapingCSolver-NumPySSASolver'] = __analyze_all_tau('TauLeapingCSolver')\n",
+    "\n",
+    "    return tau_convergence_results_analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_model_tau_convergence(model, tau_convergence_results_analysis):\n",
+    "    plt.figure()\n",
+    "    for name in tau_convergence_results_analysis:\n",
+    "        if name[0:3] == 'Tau':\n",
+    "            (x_vals, y_vals, y_errs, err_full) = tau_convergence_results_analysis[name]\n",
+    "            plt.errorbar(x_vals[1:],y_vals[1:],yerr=y_errs[1:],fmt='.-',capsize=8,label=name.split('-')[0])\n",
+    "            plt.plot([0,max(x_vals)],[y_vals[0],y_vals[0]],'.:',label=f\"{name.split('-')[0]} [AUTO]\")\n",
+    "    for name in tau_convergence_results_analysis:\n",
+    "        if name[0:3] != 'Tau':\n",
+    "            ssa_self = tau_convergence_results_analysis[name][0]\n",
+    "            plt.plot([0,max(x_vals)],[ssa_self, ssa_self], label=name)\n",
+    "    plt.ylabel(\"KS-distance\")\n",
+    "    plt.xlabel(\"tau step size\")\n",
+    "    plt.title(model.name)\n",
+    "    _=plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_model_errorbars(model, cache):\n",
+    "    plt.figure()\n",
+    "    species= list(model.listOfSpecies.keys())\n",
+    "    for s_ndx, sname in enumerate(species):\n",
+    "        plt.subplot(len(species),1,s_ndx+1)\n",
+    "        plt.title(f\"species={sname}\")\n",
+    "        for solver in cache[0]:\n",
+    "            if solver[0:3] == 'Tau':\n",
+    "                y_vals = numpy.mean(cache[0][solver][:,s_ndx,:], axis=1)\n",
+    "                x_vals = numpy.arange(len(y_vals))\n",
+    "                y_errs = numpy.var(cache[0][solver][:,s_ndx,:], axis=1)\n",
+    "                plt.errorbar(x_vals,y_vals,yerr=y_errs,fmt='.-',capsize=8,\n",
+    "                              label=solver)\n",
+    "            else:\n",
+    "                y_vals = numpy.mean(cache[0][solver]['A'][:,s_ndx,:], axis=1)\n",
+    "                x_vals = numpy.arange(len(y_vals))\n",
+    "                y_errs = numpy.var(cache[0][solver]['A'][:,s_ndx,:], axis=1)\n",
+    "                plt.errorbar(x_vals,y_vals,yerr=y_errs,fmt='.-',capsize=8,\n",
+    "                              label=solver)\n",
+    "        plt.ylabel(\"Population\")\n",
+    "        plt.xlabel(\"time\")\n",
+    "    _=plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_model_means(model, cache):\n",
+    "    species= list(model.listOfSpecies.keys())\n",
+    "    plt.figure(figsize=(12,6*len(species)))\n",
+    "    for s_ndx, sname in enumerate(species):\n",
+    "        plt.subplot(len(species),1,s_ndx+1)\n",
+    "        plt.title(f\"species={sname}\")\n",
+    "        for solver in cache[0]:\n",
+    "            if solver[0:3] == 'Tau':\n",
+    "                y_vals = numpy.mean(cache[0][solver][:,s_ndx,:], axis=1)\n",
+    "                x_vals = numpy.arange(len(y_vals))\n",
+    "                plt.plot(x_vals,y_vals,label=solver)\n",
+    "            else:\n",
+    "                y_vals = numpy.mean(cache[0][solver]['A'][:,s_ndx,:], axis=1)\n",
+    "                x_vals = numpy.arange(len(y_vals))\n",
+    "                plt.plot(x_vals,y_vals,label=solver)\n",
+    "        plt.ylabel(\"Population\")\n",
+    "        plt.xlabel(\"time\")\n",
+    "    _=plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_model_trajectories(model, cache):\n",
+    "    sol_colors = ['cyan','blue','red','green','magenta','black']\n",
+    "    species= list(model.listOfSpecies.keys())\n",
+    "    plt.figure(figsize=(12,6*len(species)))\n",
+    "    for s_ndx, sname in enumerate(species):\n",
+    "        plt.subplot(len(species),1,s_ndx+1)\n",
+    "        plt.title(f\"species={sname}\")\n",
+    "        for sol_ndx, solver in enumerate(cache[0]):\n",
+    "            #if solver == 'NumPySSASolver': continue\n",
+    "            if solver == 'SSACSolver': continue\n",
+    "            #if solver == 'TauHybridSolver': continue\n",
+    "            if solver == 'TauHybridCSolver': continue\n",
+    "            if solver == 'TauLeapingSolver': continue\n",
+    "            if solver == 'TauLeapingCSolver': continue\n",
+    "\n",
+    "            if solver[0:3] == 'Tau':\n",
+    "                #x_vals = numpy.arange(cache[0][solver].shape[0])\n",
+    "                x_vals = numpy.arange(10)\n",
+    "                for n_ndx in range(cache[0][solver].shape[2]):\n",
+    "                    y_vals = cache[0][solver][0:10,s_ndx,n_ndx]\n",
+    "                    if n_ndx==0:\n",
+    "                        plt.plot(x_vals,y_vals,color=sol_colors[sol_ndx],\n",
+    "                                 label=solver)\n",
+    "                    else:\n",
+    "                        plt.plot(x_vals,y_vals,alpha=0.01,color=sol_colors[sol_ndx])\n",
+    "            else:\n",
+    "                #x_vals = numpy.arange(cache[0][solver]['A'].shape[0])\n",
+    "                x_vals = numpy.arange(10)\n",
+    "                for n_ndx in range(cache[0][solver]['A'].shape[2]):\n",
+    "                    y_vals = cache[0][solver]['A'][0:10,s_ndx,n_ndx]\n",
+    "                    if n_ndx==0:\n",
+    "                        plt.plot(x_vals,y_vals,label=solver)\n",
+    "                    else:\n",
+    "                        plt.plot(x_vals,y_vals,alpha=0.01)\n",
+    "        plt.ylabel(\"Population\")\n",
+    "        plt.xlabel(\"time\")\n",
+    "    _=plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_model_trajectory_hist(model, cache):\n",
+    "    sol_colors = ['cyan','blue','red','green','magenta','black']\n",
+    "    species= list(model.listOfSpecies.keys())\n",
+    "    sol_blocks = [\n",
+    "        ['NumPySSASolver','TauHybridSolver','TauLeapingSolver'],\n",
+    "        ['SSACSolver','TauHybridCSolver','TauLeapingCSolver'],\n",
+    "    ]\n",
+    "    for sol_list in sol_blocks:\n",
+    "        plt.figure(figsize=(12,6*len(species)))\n",
+    "        n=1\n",
+    "        for t_ndx in range(10):\n",
+    "            for s_ndx, sname in enumerate(species):\n",
+    "                plt.subplot(10,len(species),n)\n",
+    "                n+=1\n",
+    "                plt.title(f\"{sname} t={t_ndx}\")\n",
+    "                h_colors = []\n",
+    "                h_data = []\n",
+    "                h_labels = []\n",
+    "                for sol_ndx, solver in enumerate(sol_list):\n",
+    "\n",
+    "                    if solver[0:3] == 'Tau':\n",
+    "                        #plt.hist(cache[0][solver][t_ndx,s_ndx,:],\n",
+    "                        #        color=sol_colors[s_ndx], label=solver)\n",
+    "                        h_data.append(cache[0][solver][t_ndx,s_ndx,:])\n",
+    "                        h_colors.append(sol_colors[sol_ndx])\n",
+    "                        h_labels.append(solver)\n",
+    "                    else:\n",
+    "                        #plt.hist(cache[0][solver]['A'][t_ndx,s_ndx,:],\n",
+    "                        #        color=sol_colors[s_ndx], label=solver)\n",
+    "                        h_data.append(cache[0][solver]['A'][t_ndx,s_ndx,:])\n",
+    "                        h_colors.append(sol_colors[sol_ndx])\n",
+    "                        h_labels.append(solver)\n",
+    "                plt.hist(h_data, color=h_colors, label=h_labels)\n",
+    "                #plt.ylabel(\"Population\")\n",
+    "                #plt.xlabel(\"time\")\n",
+    "                if t_ndx==0 and s_ndx==0:\n",
+    "                    _=plt.legend(loc='center left')\n",
+    "        #_=plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_model_image_maps(model, tau_convergence_results_analysis):\n",
+    "    sol_colors = ['cyan','blue','red','green','magenta','grey']\n",
+    "    species= list(model.listOfSpecies.keys())\n",
+    "    plt.figure(figsize=(12,6*len(species)))\n",
+    "    for s_ndx, sname in enumerate(species):\n",
+    "        plt.subplot(len(species),1,s_ndx+1)\n",
+    "        plt.title(f\"species={sname} (discrete)\")\n",
+    "\n",
+    "        for name in tau_convergence_results_analysis:\n",
+    "            if name[0:3] == 'Tau':\n",
+    "                (x_vals, y_vals, y_errs, err_full) = tau_convergence_results_analysis[name]\n",
+    "                plt.plot(range(10),err_full[s_ndx,0:10],label=f\"{name.split('-')[0]} [AUTO]\")\n",
+    "\n",
+    "        plt.ylabel(\"KS-distance\")\n",
+    "        plt.xlabel(\"time\")\n",
+    "        _=plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# run all models tau convergence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['create_decay', 'create_dimerization', 'create_michaelis_menten', 'create_opioid', 'create_schlogl', 'create_toggle_switch', 'create_tyson_2_state_oscillator', 'create_vilar_oscillator']\n"
+     ]
+    }
+   ],
+   "source": [
+    "all_models_tau_convergence_cache = {}\n",
+    "try:\n",
+    "    with open('all_models_tau_convergence_cache.p','rb') as fd:\n",
+    "        all_models_tau_convergence_cache = pickle.load(fd)\n",
+    "except FileNotFoundError: pass\n",
+    "print(sorted(list(all_models_tau_convergence_cache.keys())))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['create_decay',\n",
+       " 'create_dimerization',\n",
+       " 'create_michaelis_menten',\n",
+       " 'create_toggle_switch']"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "all_model_names"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Decay\n",
+      "cached  Ntraj=1000 NumPySSASolver A\n",
+      "cached  Ntraj=1000 NumPySSASolver B\n",
+      "cached  Ntraj=1000 SSACSolver A\n",
+      "cached  Ntraj=1000 SSACSolver B\n",
+      "cached  tau=<auto> TauHybridSolver\n",
+      "cached  tau=<auto> TauHybridCSolver\n",
+      "cached  tau=<auto> TauLeapingSolver\n",
+      "cached  tau=<auto> TauLeapingCSolver\n",
+      "cached  tau=1 TauHybridSolver\n",
+      "cached  tau=1 TauHybridCSolver\n",
+      "cached  tau=1 TauLeapingSolver\n",
+      "cached  tau=1 TauLeapingCSolver\n",
+      "cached  tau=0.75 TauHybridSolver\n",
+      "cached  tau=0.75 TauHybridCSolver\n",
+      "cached  tau=0.75 TauLeapingSolver\n",
+      "cached  tau=0.75 TauLeapingCSolver\n",
+      "cached  tau=0.5 TauHybridSolver\n",
+      "cached  tau=0.5 TauHybridCSolver\n",
+      "cached  tau=0.5 TauLeapingSolver\n",
+      "cached  tau=0.5 TauLeapingCSolver\n",
+      "cached  tau=0.35 TauHybridSolver\n",
+      "cached  tau=0.35 TauHybridCSolver\n",
+      "cached  tau=0.35 TauLeapingSolver\n",
+      "cached  tau=0.35 TauLeapingCSolver\n",
+      "cached  tau=0.2 TauHybridSolver\n",
+      "cached  tau=0.2 TauHybridCSolver\n",
+      "cached  tau=0.2 TauLeapingSolver\n",
+      "cached  tau=0.2 TauLeapingCSolver\n",
+      "cached  tau=0.1 TauHybridSolver\n",
+      "cached  tau=0.1 TauHybridCSolver\n",
+      "cached  tau=0.1 TauLeapingSolver\n",
+      "cached  tau=0.1 TauLeapingCSolver\n",
+      "cached  tau=0.05 TauHybridSolver\n",
+      "cached  tau=0.05 TauHybridCSolver\n",
+      "cached  tau=0.05 TauLeapingSolver\n",
+      "cached  tau=0.05 TauLeapingCSolver\n",
+      "cached  tau=0.025 TauHybridSolver\n",
+      "cached  tau=0.025 TauHybridCSolver\n",
+      "cached  tau=0.025 TauLeapingSolver\n",
+      "cached  tau=0.025 TauLeapingCSolver\n",
+      "cached  tau=0.01 TauHybridSolver\n",
+      "cached  tau=0.01 TauHybridCSolver\n",
+      "cached  tau=0.01 TauLeapingSolver\n",
+      "cached  tau=0.01 TauLeapingCSolver\n",
+      "Analyzing: NumPySSASolver-self\n",
+      "Analyzing: SSACSolver-self\n",
+      "Analyzing: NumPySSASolver-SSACSolver\n",
+      "Analyzing: TauHybridSolver-NumPySSASolver\n",
+      "Analyzing: TauHybridCSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingCSolver-NumPySSASolver\n",
+      "\t\tdone in 0.8362619876861572\n",
+      "Dimerization\n",
+      "cached  Ntraj=1000 NumPySSASolver A\n",
+      "cached  Ntraj=1000 NumPySSASolver B\n",
+      "cached  Ntraj=1000 SSACSolver A\n",
+      "cached  Ntraj=1000 SSACSolver B\n",
+      "cached  tau=<auto> TauHybridSolver\n",
+      "cached  tau=<auto> TauHybridCSolver\n",
+      "cached  tau=<auto> TauLeapingSolver\n",
+      "cached  tau=<auto> TauLeapingCSolver\n",
+      "cached  tau=1 TauHybridSolver\n",
+      "cached  tau=1 TauHybridCSolver\n",
+      "cached  tau=1 TauLeapingSolver\n",
+      "cached  tau=1 TauLeapingCSolver\n",
+      "cached  tau=0.75 TauHybridSolver\n",
+      "cached  tau=0.75 TauHybridCSolver\n",
+      "cached  tau=0.75 TauLeapingSolver\n",
+      "cached  tau=0.75 TauLeapingCSolver\n",
+      "cached  tau=0.5 TauHybridSolver\n",
+      "cached  tau=0.5 TauHybridCSolver\n",
+      "cached  tau=0.5 TauLeapingSolver\n",
+      "cached  tau=0.5 TauLeapingCSolver\n",
+      "cached  tau=0.35 TauHybridSolver\n",
+      "cached  tau=0.35 TauHybridCSolver\n",
+      "cached  tau=0.35 TauLeapingSolver\n",
+      "cached  tau=0.35 TauLeapingCSolver\n",
+      "cached  tau=0.2 TauHybridSolver\n",
+      "cached  tau=0.2 TauHybridCSolver\n",
+      "cached  tau=0.2 TauLeapingSolver\n",
+      "cached  tau=0.2 TauLeapingCSolver\n",
+      "cached  tau=0.1 TauHybridSolver\n",
+      "cached  tau=0.1 TauHybridCSolver\n",
+      "cached  tau=0.1 TauLeapingSolver\n",
+      "cached  tau=0.1 TauLeapingCSolver\n",
+      "cached  tau=0.05 TauHybridSolver\n",
+      "cached  tau=0.05 TauHybridCSolver\n",
+      "cached  tau=0.05 TauLeapingSolver\n",
+      "cached  tau=0.05 TauLeapingCSolver\n",
+      "cached  tau=0.025 TauHybridSolver\n",
+      "cached  tau=0.025 TauHybridCSolver\n",
+      "cached  tau=0.025 TauLeapingSolver\n",
+      "cached  tau=0.025 TauLeapingCSolver\n",
+      "cached  tau=0.01 TauHybridSolver\n",
+      "cached  tau=0.01 TauHybridCSolver\n",
+      "cached  tau=0.01 TauLeapingSolver\n",
+      "cached  tau=0.01 TauLeapingCSolver\n",
+      "Analyzing: NumPySSASolver-self\n",
+      "Analyzing: SSACSolver-self\n",
+      "Analyzing: NumPySSASolver-SSACSolver\n",
+      "Analyzing: TauHybridSolver-NumPySSASolver\n",
+      "Analyzing: TauHybridCSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingCSolver-NumPySSASolver\n",
+      "\t\tdone in 3.6711621284484863\n",
+      "Michaelis_Menten\n",
+      "cached  Ntraj=1000 NumPySSASolver A\n",
+      "cached  Ntraj=1000 NumPySSASolver B\n",
+      "cached  Ntraj=1000 SSACSolver A\n",
+      "cached  Ntraj=1000 SSACSolver B\n",
+      "cached  tau=<auto> TauHybridSolver\n",
+      "cached  tau=<auto> TauHybridCSolver\n",
+      "cached  tau=<auto> TauLeapingSolver\n",
+      "cached  tau=<auto> TauLeapingCSolver\n",
+      "cached  tau=1 TauHybridSolver\n",
+      "cached  tau=1 TauHybridCSolver\n",
+      "cached  tau=1 TauLeapingSolver\n",
+      "cached  tau=1 TauLeapingCSolver\n",
+      "cached  tau=0.75 TauHybridSolver\n",
+      "cached  tau=0.75 TauHybridCSolver\n",
+      "cached  tau=0.75 TauLeapingSolver\n",
+      "cached  tau=0.75 TauLeapingCSolver\n",
+      "cached  tau=0.5 TauHybridSolver\n",
+      "cached  tau=0.5 TauHybridCSolver\n",
+      "cached  tau=0.5 TauLeapingSolver\n",
+      "cached  tau=0.5 TauLeapingCSolver\n",
+      "cached  tau=0.35 TauHybridSolver\n",
+      "cached  tau=0.35 TauHybridCSolver\n",
+      "cached  tau=0.35 TauLeapingSolver\n",
+      "cached  tau=0.35 TauLeapingCSolver\n",
+      "cached  tau=0.2 TauHybridSolver\n",
+      "cached  tau=0.2 TauHybridCSolver\n",
+      "cached  tau=0.2 TauLeapingSolver\n",
+      "cached  tau=0.2 TauLeapingCSolver\n",
+      "cached  tau=0.1 TauHybridSolver\n",
+      "cached  tau=0.1 TauHybridCSolver\n",
+      "cached  tau=0.1 TauLeapingSolver\n",
+      "cached  tau=0.1 TauLeapingCSolver\n",
+      "cached  tau=0.05 TauHybridSolver\n",
+      "cached  tau=0.05 TauHybridCSolver\n",
+      "cached  tau=0.05 TauLeapingSolver\n",
+      "cached  tau=0.05 TauLeapingCSolver\n",
+      "cached  tau=0.025 TauHybridSolver\n",
+      "cached  tau=0.025 TauHybridCSolver\n",
+      "cached  tau=0.025 TauLeapingSolver\n",
+      "cached  tau=0.025 TauLeapingCSolver\n",
+      "cached  tau=0.01 TauHybridSolver\n",
+      "cached  tau=0.01 TauHybridCSolver\n",
+      "cached  tau=0.01 TauLeapingSolver\n",
+      "cached  tau=0.01 TauLeapingCSolver\n",
+      "Analyzing: NumPySSASolver-self\n",
+      "Analyzing: SSACSolver-self\n",
+      "Analyzing: NumPySSASolver-SSACSolver\n",
+      "Analyzing: TauHybridSolver-NumPySSASolver\n",
+      "Analyzing: TauHybridCSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingCSolver-NumPySSASolver\n",
+      "\t\tdone in 7.7993128299713135\n",
+      "Toggle_Switch\n",
+      "cached  Ntraj=1000 NumPySSASolver A\n",
+      "cached  Ntraj=1000 NumPySSASolver B\n",
+      "cached  Ntraj=1000 SSACSolver A\n",
+      "cached  Ntraj=1000 SSACSolver B\n",
+      "cached  tau=<auto> TauHybridSolver\n",
+      "cached  tau=<auto> TauHybridCSolver\n",
+      "cached  tau=<auto> TauLeapingSolver\n",
+      "cached  tau=<auto> TauLeapingCSolver\n",
+      "cached  tau=1 TauHybridSolver\n",
+      "cached  tau=1 TauHybridCSolver\n",
+      "cached  tau=1 TauLeapingSolver\n",
+      "cached  tau=1 TauLeapingCSolver\n",
+      "cached  tau=0.75 TauHybridSolver\n",
+      "cached  tau=0.75 TauHybridCSolver\n",
+      "cached  tau=0.75 TauLeapingSolver\n",
+      "cached  tau=0.75 TauLeapingCSolver\n",
+      "cached  tau=0.5 TauHybridSolver\n",
+      "cached  tau=0.5 TauHybridCSolver\n",
+      "cached  tau=0.5 TauLeapingSolver\n",
+      "cached  tau=0.5 TauLeapingCSolver\n",
+      "cached  tau=0.35 TauHybridSolver\n",
+      "cached  tau=0.35 TauHybridCSolver\n",
+      "cached  tau=0.35 TauLeapingSolver\n",
+      "cached  tau=0.35 TauLeapingCSolver\n",
+      "cached  tau=0.2 TauHybridSolver\n",
+      "cached  tau=0.2 TauHybridCSolver\n",
+      "cached  tau=0.2 TauLeapingSolver\n",
+      "cached  tau=0.2 TauLeapingCSolver\n",
+      "cached  tau=0.1 TauHybridSolver\n",
+      "cached  tau=0.1 TauHybridCSolver\n",
+      "cached  tau=0.1 TauLeapingSolver\n",
+      "cached  tau=0.1 TauLeapingCSolver\n",
+      "cached  tau=0.05 TauHybridSolver\n",
+      "cached  tau=0.05 TauHybridCSolver\n",
+      "cached  tau=0.05 TauLeapingSolver\n",
+      "cached  tau=0.05 TauLeapingCSolver\n",
+      "cached  tau=0.025 TauHybridSolver\n",
+      "cached  tau=0.025 TauHybridCSolver\n",
+      "cached  tau=0.025 TauLeapingSolver\n",
+      "cached  tau=0.025 TauLeapingCSolver\n",
+      "cached  tau=0.01 TauHybridSolver\n",
+      "cached  tau=0.01 TauHybridCSolver\n",
+      "cached  tau=0.01 TauLeapingSolver\n",
+      "cached  tau=0.01 TauLeapingCSolver\n",
+      "Analyzing: NumPySSASolver-self\n",
+      "Analyzing: SSACSolver-self\n",
+      "Analyzing: NumPySSASolver-SSACSolver\n",
+      "Analyzing: TauHybridSolver-NumPySSASolver\n",
+      "Analyzing: TauHybridCSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingSolver-NumPySSASolver\n",
+      "Analyzing: TauLeapingCSolver-NumPySSASolver\n",
+      "\t\tdone in 8.599974155426025\n"
+     ]
+    },
+    {
+     "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": {
+      "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"
+    }
+   ],
+   "source": [
+    "for m_ndx, mname in enumerate(all_model_names):\n",
+    "    mobj = eval(f\"example_models.{mname}\")()\n",
+    "    print(mobj.name)\n",
+    "    tic = time.time()\n",
+    "    if mname not in all_models_tau_convergence_cache:\n",
+    "        all_models_tau_convergence_cache[mname] = {}\n",
+    "    analysis_results = run_model_tau_convergence(mobj, all_models_tau_convergence_cache[mname])\n",
+    "    #plot_model_errorbars(mobj, all_models_tau_convergence_cache[mname])\n",
+    "    #plot_model_trajectories(mobj, all_models_tau_convergence_cache[mname])\n",
+    "    #plot_model_trajectory_hist(mobj, all_models_tau_convergence_cache[mname])\n",
+    "    plot_model_tau_convergence(mobj, analysis_results)\n",
+    "    #plot_model_image_maps(mobj, analysis_results)\n",
+    "    #plot_model_means(mobj, all_models_tau_convergence_cache[mname])\n",
+    "    print(f\"\\t\\tdone in {time.time()-tic}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('all_models_tau_convergence_cache.p','wb+') as fd:\n",
+    "    pickle.dump(all_models_tau_convergence_cache,fd)"
+   ]
+  },
+  {
+   "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.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.cpp b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.cpp
index 9589a83a4..e423745ce 100644
--- a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.cpp
+++ b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.cpp
@@ -296,7 +296,7 @@ namespace Gillespy
 
         // Helper method to flag reactions that can be processed deterministically (continuous change)
         // without exceeding the user-supplied tolerance
-        std::set<int> flag_det_rxns(
+        int flag_det_rxns(
                 std::vector<HybridReaction> &reactions,
                 std::vector<HybridSpecies> &species)
         {
@@ -337,7 +337,7 @@ namespace Gillespy
                 }
             }
 
-            return det_rxns;
+            return det_rxns.size();
         }
 
         void partition_species(
diff --git a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.h b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.h
index 26be03d46..b42320a3b 100644
--- a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.h
+++ b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/HybridModel.h
@@ -304,7 +304,7 @@ namespace Gillespy
             };
         };
 
-        std::set<int> flag_det_rxns(
+        int flag_det_rxns(
                 std::vector<HybridReaction> &reactions,
                 std::vector<HybridSpecies> &species);
 
diff --git a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/TauHybridSolver.cpp b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/TauHybridSolver.cpp
index 64a21bdf5..2790a498e 100644
--- a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/TauHybridSolver.cpp
+++ b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/TauHybridSolver.cpp
@@ -35,6 +35,9 @@
 #include "integrator.h"
 #include "tau.h"
 
+#include "template_defaults.h"
+
+
 static void silent_error_handler(int error_code, const char *module, const char *function_name,
                           char *message, void *eh_data);
 
@@ -52,8 +55,7 @@ namespace Gillespy
     {
         void CalculateSpeciesChangeAfterStep(IntegrationResults&result, int*population_changes,
          std::vector<double> current_state, std::set<unsigned int>&rxn_roots, 
-         std::set<int>&event_roots, HybridSimulation*simulation, URNGenerator&urn, 
-         int only_reaction_to_fire){
+         std::set<int>&event_roots, HybridSimulation*simulation, URNGenerator&urn){
             Model<double> &model = *(simulation->model);
             int num_species = model.number_species;
             int num_reactions = model.number_reactions;
@@ -88,12 +90,13 @@ namespace Gillespy
 
                     if (simulation->reaction_state[rxn_i].mode == SimulationState::DISCRETE) {
                         unsigned int rxn_count = 0;
-                        if(only_reaction_to_fire > -1){
-                            if(only_reaction_to_fire == rxn_i){
-                                    rxn_state = log(urn.next());
-                                    rxn_count = 1;
-                            }
-                        }else if(rxn_state > 0){
+                        //if(only_reaction_to_fire > -1){
+                        //    if(only_reaction_to_fire == rxn_i){
+                        //            rxn_state = log(urn.next());
+                        //            rxn_count = 1;
+                        //    }
+                        //}else
+                        if(rxn_state > 0){
                             std::poisson_distribution<int> poisson(rxn_state);
                             rxn_count = 1 + poisson(generator);
                             rxn_state = log(urn.next());
@@ -113,20 +116,24 @@ namespace Gillespy
         bool TakeIntegrationStep(Integrator&sol, IntegrationResults&result, double *next_time, int*population_changes,
          std::vector<double> current_state, std::set<unsigned int>&rxn_roots, 
          std::set<int>&event_roots, HybridSimulation*simulation, URNGenerator&urn, 
-         int only_reaction_to_fire){
+         int num_det_rxns, int num_rate_rules){
             // Integration Step
+
+            // check to see if we can do a constant integration (no deterministic reactions or rate rules)
+
             // For deterministic reactions, the concentrations are updated directly.
             // For stochastic reactions, integration updates the rxn_offsets vector.
-            result = sol.integrate(next_time, event_roots, rxn_roots);
+            result = sol.integrate(next_time, event_roots, rxn_roots, num_det_rxns, num_rate_rules);
             if (sol.status == IntegrationStatus::BAD_STEP_SIZE)
             {
                 simulation->set_status(HybridSimulation::INTEGRATOR_FAILED);
                 return false;
-            } else {
-                // The integrator has, at this point, been validated.
-                // Any errors beyond this point is assumed to be a stochastic state failure.
-                CalculateSpeciesChangeAfterStep(result, population_changes, current_state, rxn_roots, event_roots, simulation, urn, only_reaction_to_fire);
             }
+
+
+            // The integrator has, at this point, been validated.
+            // Any errors beyond this point is assumed to be a stochastic state failure.
+            CalculateSpeciesChangeAfterStep(result, population_changes, current_state, rxn_roots, event_roots, simulation, urn);
             return true;
         }
 
@@ -171,6 +178,7 @@ namespace Gillespy
             GPY_INTERRUPT_INSTALL_HANDLER(signal_handler);
 
             Model<double> &model = *(simulation->model);
+            int num_rate_rules = 0;
             int num_species = model.number_species;
             int num_reactions = model.number_reactions;
             int num_trajectories = simulation->number_trajectories;
@@ -182,6 +190,9 @@ namespace Gillespy
             std::vector<int> non_negative_species;
 
             for (int spec = 0; spec < model.number_species; spec++) {
+                HybridSpecies *specO = &simulation->species_state[spec];
+                num_rate_rules += specO->diff_equation.rate_rules.size();
+
                 for (int r = 0; r < model.number_reactions; r++) {
                     if (model.reactions[r].products_change[spec] > 0 ||
                         model.reactions[r].reactants_change[spec] > 0) {
@@ -282,6 +293,12 @@ namespace Gillespy
                     s_vars[s_num_i] = saved__s_variables[s_num_i];
                 }
 
+                // reset R_j values
+                double *curr_rxn_state = sol.get_reaction_state();
+                for (unsigned int rxn_j = 0; rxn_j < num_reactions; ++rxn_j) {
+                    curr_rxn_state[rxn_j] = log(urn.next()); 
+                }
+
 
                 while (!interrupted && !invalid_state && simulation->current_time < simulation->end_time)
                 {
@@ -313,15 +330,19 @@ namespace Gillespy
                     }
 
                     // Expected tau step is determined.
-                    tau_step = select<double, double>(
-                            model,
-                            tau_args,
-                            tau_tol,
-                            simulation->current_time,
-                            save_time,
-                            sol.data.propensities,
-                            current_state
-                    );
+                    if(GPY_CONSTANT_TAU_STEPSIZE > 0){
+                        tau_step = GPY_CONSTANT_TAU_STEPSIZE;
+                    }else{
+                        tau_step = select<double, double>(
+                                model,
+                                tau_args,
+                                tau_tol,
+                                simulation->current_time,
+                                save_time,
+                                sol.data.propensities,
+                                current_state
+                        );
+                    }
                     partition_species(
                             simulation->current_time,
                             simulation->reaction_state,
@@ -331,7 +352,7 @@ namespace Gillespy
                             tau_step,
                             tau_args
                     );
-                    flag_det_rxns(
+                    int num_det_rxns = flag_det_rxns(
                             simulation->reaction_state,
                             simulation->species_state
                     );
@@ -371,7 +392,7 @@ namespace Gillespy
                     }
 
 
-                    if(!TauHybrid::TakeIntegrationStep(sol, result, &next_time, population_changes, current_state, rxn_roots, event_roots, simulation, urn, -1)){
+                    if(!TauHybrid::TakeIntegrationStep(sol, result, &next_time, population_changes, current_state, rxn_roots, event_roots, simulation, urn, num_det_rxns, num_rate_rules)){
                         return;
                     }
 
diff --git a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.cpp b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.cpp
index 4d6809cea..0a12a06c4 100644
--- a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.cpp
+++ b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.cpp
@@ -123,6 +123,47 @@ Integrator::~Integrator()
     delete[] m_roots;
 }
 
+IntegrationResults Integrator::integrate_constant(double *t)
+{
+    // this function assumes no deterministic species or 
+    realtype *Y = N_VGetArrayPointer(y);
+    HybridSimulation *sim = data.simulation;
+    std::vector<HybridSpecies> *species = data.species_state;
+    std::vector<HybridReaction> *reactions = data.reaction_state;
+    std::vector<double> &propensities = data.propensities;
+    unsigned int num_species = sim->model->number_species;
+    unsigned int num_reactions = sim->model->number_reactions;
+    realtype propensity;
+    for (unsigned int rxn_i = 0; rxn_i < num_reactions; ++rxn_i)
+    {
+        HybridReaction rxn = (*reactions)[rxn_i];
+        switch (rxn.mode) {
+        case SimulationState::DISCRETE:
+            // Process stochastic reaction state by updating the root offset for each reaction.
+            propensity = rxn.ssa_propensity(Y);
+            propensities[rxn_i] = propensity;
+            break;
+
+        case SimulationState::CONTINUOUS:
+            break;
+        default:
+            break;
+        }
+    }
+
+    double tau = *t - this->t;
+    for (int rxn_i = 0; rxn_i < num_reactions; ++rxn_i){
+        NV_Ith_S(y, rxn_i+num_species) = NV_Ith_S(y, rxn_i+num_species) + propensities[rxn_i] * tau;
+    }
+    this->t = *t;
+
+    return {
+        NV_DATA_S(y),
+        NV_DATA_S(y) + num_species,
+        IntegrationStatus::OK
+    };
+}
+
 IntegrationResults Integrator::integrate(double *t)
 {
     int retcode = CVode(cvode_mem, *t, y, &this->t, CV_NORMAL);
@@ -157,9 +198,15 @@ void Integrator::reset_model_vector()
     }
 }
 
-IntegrationResults Integrator::integrate(double *t, std::set<int> &event_roots, std::set<unsigned int> &reaction_roots)
+IntegrationResults Integrator::integrate(double *t, std::set<int> &event_roots, std::set<unsigned int> &reaction_roots, int num_det_rxns, int num_rate_rules)
 {
-    IntegrationResults results = integrate(t);
+
+    IntegrationResults results;
+    if(num_det_rxns == 0 && num_rate_rules == 0 &&  data.active_triggers.size() == 0 && data.active_reaction_ids.size() == 0){
+        results = integrate_constant(t);
+    }else{
+        results = integrate(t);
+    }
     if (status != IntegrationStatus::OK) {
         return results;
     }
diff --git a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.h b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.h
index 1aa0a1e4a..54737aa71 100644
--- a/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.h
+++ b/gillespy2/solvers/cpp/c_base/tau_hybrid_cpp_solver/integrator.h
@@ -196,7 +196,8 @@ namespace Gillespy
 		}
 
         IntegrationResults integrate(double *t);
-        IntegrationResults integrate(double *t, std::set<int> &event_roots, std::set<unsigned int> &reaction_roots);
+        IntegrationResults integrate_constant(double *t);
+        IntegrationResults integrate(double *t, std::set<int> &event_roots, std::set<unsigned int> &reaction_roots, int num_det_rxns, int num_rate_rules);
         IntegratorData data;
 
         Integrator(HybridSimulation *simulation, Model<double> &model, URNGenerator urn, double reltol, double abstol);
diff --git a/gillespy2/solvers/cpp/c_base/tau_leaping_cpp_solver/TauLeapingSolver.cpp b/gillespy2/solvers/cpp/c_base/tau_leaping_cpp_solver/TauLeapingSolver.cpp
index bea501868..9b1572615 100644
--- a/gillespy2/solvers/cpp/c_base/tau_leaping_cpp_solver/TauLeapingSolver.cpp
+++ b/gillespy2/solvers/cpp/c_base/tau_leaping_cpp_solver/TauLeapingSolver.cpp
@@ -31,6 +31,8 @@
 #include "TauLeapingSolver.h"
 #include "tau.h"
 
+#include "template_defaults.h"
+
 namespace Gillespy
 {
     static volatile bool interrupted = false;
@@ -149,8 +151,11 @@ namespace Gillespy
                     {
                         propensity_values[reaction_number] = Reaction::propensity(reaction_number, current_state.data());
                     }
-
-                    tau_step = select(*(simulation->model), tau_args, tau_tol, simulation->current_time, save_time, propensity_values, current_state);
+                    if(GPY_CONSTANT_TAU_STEPSIZE > 0){
+                        tau_step = GPY_CONSTANT_TAU_STEPSIZE;
+                    }else{
+                        tau_step = select(*(simulation->model), tau_args, tau_tol, simulation->current_time, save_time, propensity_values, current_state);
+                    }
                     prev_curr_state = current_state;
                     double prev_curr_time = simulation->current_time;
                     int loop_cnt = 0;
diff --git a/gillespy2/solvers/cpp/c_base/template/template_defaults.h b/gillespy2/solvers/cpp/c_base/template/template_defaults.h
index 15a94b906..858e17c2f 100644
--- a/gillespy2/solvers/cpp/c_base/template/template_defaults.h
+++ b/gillespy2/solvers/cpp/c_base/template/template_defaults.h
@@ -63,6 +63,11 @@
 #define GPY_REACTION_NAMES
 #endif
 
+
+#ifndef GPY_CONSTANT_TAU_STEPSIZE
+#define GPY_CONSTANT_TAU_STEPSIZE 0 
+#endif
+
 // ===============================================================
 // ================ HYBRID SOLVER OPTION DEFAULTS ================
 // ===============================================================
@@ -77,6 +82,7 @@
  * SPECIES_MODE(1, CONTINUOUS_MODE) \
  * SPECIES_MODE(2, DYNAMIC_MODE)
  */
+
 #ifdef GPY_SOLVER_HYBRID
 
 #ifndef GPY_HYBRID_SPECIES_MODES
@@ -89,3 +95,4 @@
 
 #endif
 
+
diff --git a/gillespy2/solvers/cpp/tau_hybrid_c_solver.py b/gillespy2/solvers/cpp/tau_hybrid_c_solver.py
index bd06d1b29..75847c465 100644
--- a/gillespy2/solvers/cpp/tau_hybrid_c_solver.py
+++ b/gillespy2/solvers/cpp/tau_hybrid_c_solver.py
@@ -22,6 +22,12 @@ class TauHybridCSolver(GillesPySolver, CSolver):
     name = "TauHybridCSolver"
     target = "hybrid"
 
+    def __init__(self, model = None, output_directory = None, delete_directory = True, resume=None, variable = False,  constant_tau_stepsize=None):
+
+        self.constant_tau_stepsize = constant_tau_stepsize
+        super().__init__(model=model, output_directory=output_directory, 
+                         delete_directory=delete_directory, resume=resume, variable=variable)
+
     class ErrorStatus(IntEnum):
         UNKNOWN = 1
         LOOP_OVER_INTEGRATE = 2
@@ -30,8 +36,7 @@ class ErrorStatus(IntEnum):
         NEGATIVE_STATE_NO_SSA_REACTION = 5
         NEGATIVE_STATE_AT_BEGINING_OF_STEP = 6
 
-    @classmethod
-    def __create_options(cls, sanitized_model: "SanitizedModel") -> "SanitizedModel":
+    def __create_options(self, sanitized_model: "SanitizedModel") -> "SanitizedModel":
         """
         Populate the given list of species modes into a set of template macro definitions.
         Generated options are specific to the Tau Hybrid solver,
@@ -169,14 +174,25 @@ def get_supported_features(cls):
     def get_supported_integrator_options(cls) -> "Set[str]":
         return { "rtol", "atol", "max_step" }
 
+
+
     def _build(self, model: "Union[Model, SanitizedModel]", simulation_name: str, variable: bool, debug: bool = False,
                custom_definitions=None) -> str:
         variable = variable or len(model.listOfEvents) > 0
-        sanitized_model = TauHybridCSolver.__create_options(SanitizedModel(model, variable=variable))
+        sanitized_model = self.__create_options(SanitizedModel(model, variable=variable))
         for rate_rule in model.listOfRateRules.values():
             sanitized_model.use_rate_rule(rate_rule)
+
+        # determine if a constant stepsize has been requested
+        if self.constant_tau_stepsize is not None:
+            sanitized_model.options['GPY_CONSTANT_TAU_STEPSIZE'] = str(float(self.constant_tau_stepsize))
+        else:
+            sanitized_model.options['GPY_CONSTANT_TAU_STEPSIZE'] = '0'
         return super()._build(sanitized_model, simulation_name, variable, debug)
 
+
+
+
     def _handle_return_code(self, return_code: "int") -> "int":
         if return_code == TauHybridCSolver.ErrorStatus.UNKNOWN:
             raise SimulationError("C++ solver failed (no error code given).")
@@ -270,10 +286,12 @@ def run(self=None, model: Model = None, t: int = None, number_of_trajectories: i
                 raise SimulationError("A model is required to run the simulation.")
             self._set_model(model=model)
 
+
         self.model.compile_prep()
         self.validate_model(self.model, model)
         self.validate_sbml_features(model=self.model)
 
+
         self.validate_tspan(increment=increment, t=t)
         if increment is None:
             increment = self.model.tspan[-1] - self.model.tspan[-2]
diff --git a/gillespy2/solvers/cpp/tau_leaping_c_solver.py b/gillespy2/solvers/cpp/tau_leaping_c_solver.py
index 303c2024f..c52042d37 100644
--- a/gillespy2/solvers/cpp/tau_leaping_c_solver.py
+++ b/gillespy2/solvers/cpp/tau_leaping_c_solver.py
@@ -23,6 +23,9 @@
 
 from .c_solver import CSolver, SimulationReturnCode
 
+from gillespy2.solvers.cpp.build.template_gen import SanitizedModel
+
+
 class TauLeapingCSolver(GillesPySolver, CSolver):
 
     """
@@ -35,6 +38,23 @@ class TauLeapingCSolver(GillesPySolver, CSolver):
     name = "TauLeapingCSolver"
     target = "tau_leap"
 
+    def __init__(self, model = None, output_directory = None, delete_directory = True, resume=None, variable = False,  constant_tau_stepsize=None):
+
+        self.constant_tau_stepsize = constant_tau_stepsize
+        super().__init__(model=model, output_directory=output_directory, 
+                         delete_directory=delete_directory, resume=resume, variable=variable) 
+
+    def _build(self, model, simulation_name, variable, debug = False,
+               custom_definitions=None):
+        sanitized_model = SanitizedModel(model, variable=variable)
+        # determine if a constant stepsize has been requested
+        if self.constant_tau_stepsize is not None:
+            sanitized_model.options['GPY_CONSTANT_TAU_STEPSIZE'] = str(float(self.constant_tau_stepsize))
+        else:
+            sanitized_model.options['GPY_CONSTANT_TAU_STEPSIZE'] = '0'
+        return super()._build(sanitized_model, simulation_name, variable, debug)
+
+
     @classmethod
     def get_solver_settings(cls):
         """
@@ -46,7 +66,7 @@ def get_solver_settings(cls):
 
     def run(self=None, model: Model = None, t: int = None, number_of_trajectories: int = 1, timeout: int = 0,
             increment: int = None, seed: int = None, debug: bool = False, profile: bool = False, variables={},
-            resume=None, live_output: str = None, live_output_options: dict = {}, tau_tol=0.03, **kwargs):
+            resume=None, live_output: str = None, live_output_options: dict = {}, tau_tol=0.03, constant_tau_stepsize=None, **kwargs):
 
         """
         :param model: The model on which the solver will operate. (Deprecated)
@@ -85,6 +105,8 @@ def run(self=None, model: Model = None, t: int = None, number_of_trajectories: i
         result in larger tau steps. Default value is 0.03.
         :type tau_tol: float
 
+        :param constant_tau_stepsize: If set, overrides the automatic stepsize selection and uses the given
+                    value as the stepsize on each step.
         :returns: A result object containing the results of the simulation
         :rtype: gillespy2.Results
         """
@@ -111,6 +133,8 @@ def run(self=None, model: Model = None, t: int = None, number_of_trajectories: i
                 raise SimulationError("A model is required to run the simulation.")
             self._set_model(model=model)
 
+        self.constant_tau_stepsize = constant_tau_stepsize
+
         self.model.compile_prep()
         self.validate_model(self.model, model)
         self.validate_sbml_features(model=self.model)
diff --git a/gillespy2/solvers/numpy/tau_hybrid_solver.py b/gillespy2/solvers/numpy/tau_hybrid_solver.py
index 647bf08b4..2972d4286 100644
--- a/gillespy2/solvers/numpy/tau_hybrid_solver.py
+++ b/gillespy2/solvers/numpy/tau_hybrid_solver.py
@@ -32,16 +32,16 @@
 def __piecewise(*args):
     # Eval entry for piecewise functions
     args = list(args)
-    sol = None
+    solution = None
     if len(args) % 2:
         args.append(True)
     for i, arg in enumerate(args):
         if not i % 2:
             continue
         if arg:
-            sol = args[i - 1]
+            solution = args[i - 1]
             break
-    return sol
+    return solution
 
 
 def __xor(*args):
@@ -73,7 +73,7 @@ class TauHybridSolver(GillesPySolver):
     result = None
     stop_event = None
 
-    def __init__(self, model=None, profile_reactions=False):
+    def __init__(self, model=None, profile_reactions=False, constant_tau_stepsize=None):
         if model is None:
             raise SimulationError("A model is required to run the simulation.")
 
@@ -93,6 +93,17 @@ def __init__(self, model=None, profile_reactions=False):
                 self.non_negative_species.add(key.name)
             for key, value in model.listOfReactions[reaction].products.items():
                 self.non_negative_species.add(key.name)
+        self.constant_tau_stepsize = constant_tau_stepsize
+        # check if model should skip ODE integration step
+        self.pure_discrete = False
+        if len(self.model.listOfRateRules)==0:
+            self.pure_discrete = True
+            for species in self.model.listOfSpecies:
+                if self.model.listOfSpecies[species].mode != 'discrete':
+                    self.pure_discrete = False
+                    break
+
+
 
     def __save_state_to_output(self, curr_time, save_index, curr_state, species, 
                                 trajectory, save_times):
@@ -488,7 +499,7 @@ def __check_t0_events(self, initial_state):
                         t0_delayed_events[e.name] = execution_time
         return t0_delayed_events, species_modified_by_events
 
-    def __update_stochastic_rxn_states(self, compiled_reactions, curr_state, only_update=None):
+    def __update_stochastic_rxn_states(self, propensities, tau_step, compiled_reactions, curr_state, only_update=None):
         """
         Helper method for updating the state of stochastic reactions.
 
@@ -503,12 +514,12 @@ def __update_stochastic_rxn_states(self, compiled_reactions, curr_state, only_up
             rxn_count[rxn] = 0
             if only_update is not None:  # for a single SSA step
                 if rxn == only_update:
-                    curr_state[rxn] = math.log(random.uniform(0, 1)) #set this value, needs to be <0
+                    curr_state[rxn] = math.log(np.random.uniform(0, 1)) #set this value, needs to be <0
                     rxn_count[rxn] = 1
-            else:  # for a normal Tau-step
-                while curr_state[rxn] > 0:
-                    rxn_count[rxn] += 1
-                    curr_state[rxn] += math.log(random.uniform(0, 1))
+            elif curr_state[rxn] > 0:
+                rxn_count[rxn] = 1 + np.random.poisson(curr_state[rxn])
+                curr_state[rxn] = math.log(np.random.uniform(0, 1))
+
             if rxn_count[rxn]:
                 for reactant in self.model.listOfReactions[rxn].reactants:
                     species_modified[reactant.name] = True
@@ -518,19 +529,63 @@ def __update_stochastic_rxn_states(self, compiled_reactions, curr_state, only_up
                     curr_state[product.name] += self.model.listOfReactions[rxn].products[product] * rxn_count[rxn]
         return species_modified, rxn_count
 
-    def __integrate(self, integrator_options, curr_state, y0, curr_time,
+    def __integrate_constant(self, integrator_options, curr_state, y0, curr_time,
                     propensities, y_map, compiled_reactions,
                     active_rr, event_queue,
                     delayed_events, trigger_states,
                     event_sensitivity, tau_step ):
         """
+        Integreate one step, skip ODE integrator as all species are 
+        discrete.
+        """
+        tau_step = max(1e-6, tau_step)
+        next_tau = curr_time + tau_step
+        prev_time = curr_time
+        curr_state['t'] = curr_time
+        curr_state['time'] = curr_time
+        
+        event_times = {}
+        reaction_times = []
+        next_step, curr_time = self.__get_next_step(event_times, reaction_times,
+                                                    delayed_events,
+                                                    self.model.tspan[-1], next_tau)
+        curr_state['t'] = curr_time
+
+        tau_step2 = curr_time - prev_time
+
+        for rxn in compiled_reactions:
+            curr_state[rxn] = curr_state[rxn] + propensities[rxn]*tau_step2
+
+        return curr_time, tau_step2
+
+
+
+    def __integrate(self, integrator_options, curr_state, y0, curr_time,
+                    propensities, y_map, compiled_reactions,
+                    active_rr, event_queue,
+                    delayed_events, trigger_states,
+                    event_sensitivity, tau_step, det_rxn ):
+        """
         Helper function to perform the ODE integration of one step.  This
         method uses scipy.integrate.LSODA to get simulation data, and
         determines the next stopping point of the simulation. The state is
         updated and returned to __simulate along with curr_time and the
         solution object.
         """
-        max_step_size = self.model.tspan[1] - self.model.tspan[0] / 100
+        use_const = False
+        if self.pure_discrete:
+            use_const = True
+        elif len(self.model.listOfRateRules)==0:
+            use_const = True
+            for rxn in det_rxn:
+                if det_rxn[rxn]:
+                    use_const = False
+                    break
+
+        if use_const:
+            return self.__integrate_constant(integrator_options, curr_state, y0, curr_time,
+                            propensities, y_map, compiled_reactions, active_rr, event_queue,
+                            delayed_events, trigger_states, event_sensitivity, tau_step)
 
         from functools import partial
         events = self.model.listOfEvents.values()
@@ -547,15 +602,27 @@ def __integrate(self, integrator_options, curr_state, y0, curr_time,
             tau_step = max(integrator_options['min_step'], tau_step)
         else:
             tau_step = max(1e-6, tau_step)
-        next_tau = curr_time + tau_step
+        #next_tau = curr_time + tau_step
+        last_curr_time = curr_time
+
+        # Set curr time to next time a change occurs in the system outside of
+        # the standard ODE process.  Determine what kind of change this is,
+        # and set the curr_time of simulation to restart simulation after
+        # making the appropriate state changes.
+        event_times = {}
+        reaction_times = []
+        next_step, curr_time = self.__get_next_step(event_times, reaction_times,
+                                                    delayed_events,
+                                                    self.model.tspan[-1], curr_time + tau_step)
         curr_state['t'] = curr_time
         curr_state['time'] = curr_time
+        actual_tau_step = last_curr_time - curr_time
 
         # Integrate until end or tau is reached
         loop_count = 0
-        sol = LSODA(rhs, curr_time, y0, next_tau)
+        sol = LSODA(rhs, last_curr_time, y0, curr_time)
         counter = 0
-        while sol.t < next_tau:
+        while sol.t < curr_time:
             counter += 1
             sol.step()
 
@@ -580,16 +647,6 @@ def __integrate(self, integrator_options, curr_state, y0, curr_time,
         # Get next tau time
         reaction_times = []
         '''
-        # Set curr time to next time a change occurs in the system outside of
-        # the standard ODE process.  Determine what kind of change this is,
-        # and set the curr_time of simulation to restart simulation after
-        # making the appropriate state changes.
-        event_times = {}
-        reaction_times = []
-        next_step, curr_time = self.__get_next_step(event_times, reaction_times,
-                                                    delayed_events,
-                                                    self.model.tspan[-1], next_tau)
-        curr_state['t'] = curr_time
 
         # Stochastic Reactions are also fired through a root-finding method
         # which mirrors the standard SSA probability.  Since we are using
@@ -625,7 +682,7 @@ def __integrate(self, integrator_options, curr_state, y0, curr_time,
             event = heapq.heappop(delayed_events)
             heapq.heappush(event_queue, (eval(self.model.listOfEvents[event[1]].priority), event[1]))
 
-        return sol, curr_time
+        return curr_time, actual_tau_step
 
 
     def __simulate_negative_state_check(self, curr_state):
@@ -649,7 +706,7 @@ def __simulate(self, integrator_options, curr_state, y0, curr_time,
                    propensities, species, parameters, compiled_reactions,
                    active_rr, y_map, trajectory, save_times, save_index,
                    delayed_events, trigger_states, event_sensitivity,
-                   tau_step, debug, det_spec):
+                   tau_step, debug, det_spec, det_rxn):
         """
         Function to process simulation until next step, which can be a
         stochastic reaction firing, an event trigger or assignment, or end of
@@ -665,8 +722,6 @@ def __simulate(self, integrator_options, curr_state, y0, curr_time,
         :type save_times: list
 
         :returns: curr_state, curr_time, save_times, sol
-            sol - Python object returned from LSODA which contains all solution
-            data.
         """
 
         # first check if we have a valid state:
@@ -700,9 +755,9 @@ def __simulate(self, integrator_options, curr_state, y0, curr_time,
         # check each reaction to see if it is >=0. If we have taken a single SSA step, this could be >0 for the non-selected reactions, check if propensity is zero and reset if so
         for r in compiled_reactions.keys():
             if curr_state[r] >= 0 and propensities[r] == 0:
-                curr_state[r] = math.log(random.uniform(0, 1))
+                curr_state[r] = math.log(np.random.uniform(0, 1))
 
-        sol, curr_time = self.__integrate(integrator_options, curr_state,
+        curr_time, actual_tau_step = self.__integrate(integrator_options, curr_state,
                                           y0, curr_time, propensities, y_map,
                                           compiled_reactions,
                                           active_rr,
@@ -710,10 +765,10 @@ def __simulate(self, integrator_options, curr_state, y0, curr_time,
                                           delayed_events,
                                           trigger_states,
                                           event_sensitivity,
-                                          tau_step
+                                          tau_step, det_rxn
                                           )
 
-        species_modified,rxn_count = self.__update_stochastic_rxn_states(compiled_reactions, curr_state)
+        species_modified,rxn_count = self.__update_stochastic_rxn_states(propensities, actual_tau_step, compiled_reactions, curr_state)
 
         # Occasionally, a tau step can result in an overly-aggressive
         # forward step and cause a species population to fall below 0,
@@ -762,7 +817,7 @@ def __simulate(self, integrator_options, curr_state, y0, curr_time,
 
             tau_step = min_tau #estimated time to the first stochatic reaction
 
-            sol, curr_time = self.__integrate(integrator_options, curr_state,
+            curr_time, actual_tau_step = self.__integrate(integrator_options, curr_state,
                                           y0, curr_time, propensities, y_map,
                                           compiled_reactions,
                                           active_rr,
@@ -770,13 +825,13 @@ def __simulate(self, integrator_options, curr_state, y0, curr_time,
                                           delayed_events,
                                           trigger_states,
                                           event_sensitivity,
-                                          tau_step
+                                          tau_step, det_rxn
                                           )
 
             # only update the selected reaction
             first_rxn_count = copy.deepcopy(rxn_count)
             first_err_message = invalid_err_message
-            species_modified,rxn_count = self.__update_stochastic_rxn_states(compiled_reactions, curr_state, only_update=rxn_selected)
+            species_modified,rxn_count = self.__update_stochastic_rxn_states(propensities, actual_tau_step, compiled_reactions, curr_state, only_update=rxn_selected)
 
             (invalid_state, invalid_err_message) = self.__simulate_invalid_state_check(species_modified, curr_state, compiled_reactions)
             if invalid_state:
@@ -804,7 +859,7 @@ def __simulate(self, integrator_options, curr_state, y0, curr_time,
 
         events_processed = self.__process_queued_events(event_queue, trigger_states, curr_state, det_spec)
 
-        return sol, curr_state, curr_time, save_times, save_index
+        return curr_state, curr_time, save_times, save_index
 
     def __set_seed(self, seed):
         # Set seed if supplied
@@ -812,7 +867,7 @@ def __set_seed(self, seed):
             if not isinstance(seed, int):
                 seed = int(seed)
             if seed > 0:
-                random.seed(seed)
+                np.random.seed(seed)
             else:
                 raise ModelError('seed must be a positive integer')
 
@@ -866,7 +921,7 @@ def __initialize_state(self, curr_state, debug):
 
         # Set reactions to uniform random number
         for i, r in enumerate(self.model.listOfReactions):
-            curr_state[r] = math.log(random.uniform(0, 1))
+            curr_state[r] = math.log(np.random.uniform(0, 1))
             if debug:
                 print("Setting Random number ", curr_state[r], " for ", self.model.listOfReactions[r].name)
 
@@ -1013,6 +1068,7 @@ def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None,
         self.validate_model(self.model, model)
         self.validate_sbml_features(model=self.model)
 
+
         self.validate_tspan(increment=increment, t=t)
         if increment is None:
             increment = self.model.tspan[-1] - self.model.tspan[-2]
@@ -1195,6 +1251,11 @@ def __run(self, curr_state, curr_time, timeline, trajectory_base, initial_state,
             curr_state[0] = initial_state.copy()
             curr_time[0] = 0  # Current Simulation Time
 
+            for i, r in enumerate(self.model.listOfReactions):
+                curr_state[0][r] = math.log(np.random.uniform(0, 1))
+                if debug:
+                    print("Setting Random number ", curr_state[0][r], " for ", self.model.listOfReactions[r].name)
+
             end_time = self.model.tspan[-1]  # End of Simulation time
             entry_pos = 1
             data = OrderedDict()  # Dictionary for results
@@ -1239,12 +1300,21 @@ def __run(self, curr_state, curr_time, timeline, trajectory_base, initial_state,
                         propensities[r] = eval(compiled_propensities[r], eval_globals, curr_state[0])
                         if curr_state[0][r] > 0 and propensities[r]==0:
                             # This is an edge case, that might happen after a single SSA step.
-                            curr_state[0][r] = math.log(random.uniform(0, 1))
+                            curr_state[0][r] = math.log(np.random.uniform(0, 1))
                     except Exception as e:
                         raise SimulationError('Error calculation propensity for {0}.\nReason: {1}\ncurr_state={2}'.format(r, e, curr_state))
 
                 # Calculate Tau statistics and select a good tau step
-                tau_step = Tau.select(HOR, reactants, mu_i, sigma_i, g_i, epsilon_i, tau_tol, critical_threshold, self.model, propensities, curr_state[0], curr_time[0], save_times[0])
+                if self.constant_tau_stepsize is None:
+                    tau_step = Tau.select(HOR, reactants, mu_i, sigma_i, g_i, epsilon_i, tau_tol, critical_threshold, self.model, propensities, curr_state[0], curr_time[0], save_times[0])
+                else:
+                    tau_step = self.constant_tau_stepsize
+                if debug:
+                    X = ''
+                    for k,v in curr_state[0].items():
+                        X+= f'{k}:{v:.2f} '
+                    print(f"t={curr_time[0]} tau={tau_step} curr_state={X}")
+
 
                 # Process switching if used
                 mn, sd, CV = self.__calculate_statistics(curr_time[0], propensities, curr_state[0], tau_step, det_spec)
@@ -1269,7 +1339,7 @@ def __run(self, curr_state, curr_time, timeline, trajectory_base, initial_state,
                                              compiled_reactions, self.model.listOfEvents, curr_state[0])
 
                 # Run simulation to next step
-                sol, curr_state[0], curr_time[0], save_times, save_index = self.__simulate(integrator_options,
+                curr_state[0], curr_time[0], save_times, save_index = self.__simulate(integrator_options,
                                                                                curr_state[0], y0, curr_time[0],
                                                                                propensities, species,
                                                                                parameters, compiled_reactions,
@@ -1278,7 +1348,7 @@ def __run(self, curr_state, curr_time, timeline, trajectory_base, initial_state,
                                                                                delayed_events,
                                                                                trigger_states,
                                                                                event_sensitivity, tau_step,
-                                                                               debug, det_spec)
+                                                                               debug, det_spec, det_rxn)
 
             # End of trajectory, format results
             data = {'time': timeline}
diff --git a/gillespy2/solvers/numpy/tau_leaping_solver.py b/gillespy2/solvers/numpy/tau_leaping_solver.py
index 61974a2c7..d76e57845 100644
--- a/gillespy2/solvers/numpy/tau_leaping_solver.py
+++ b/gillespy2/solvers/numpy/tau_leaping_solver.py
@@ -43,7 +43,7 @@ class TauLeapingSolver(GillesPySolver):
     pause_event = None
     result = None
 
-    def __init__(self, model=None, debug=False):
+    def __init__(self, model=None, debug=False, constant_tau_stepsize=None):
         if model is None:
             raise SimulationError("A model is required to run the simulation.")
 
@@ -55,6 +55,7 @@ def __init__(self, model=None, debug=False):
         self.model = copy.deepcopy(model)
         self.debug = debug
         self.is_instantiated = True
+        self.constant_tau_stepsize = constant_tau_stepsize
 
     def __get_reactions(self, step, curr_state, curr_time, save_time, propensities, reactions):
         """
@@ -142,7 +143,7 @@ def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None,
         :param tau_tol: Tolerance level for Tau leaping algorithm.  Larger tolerance values will
             result in larger tau steps. Default value is 0.03.
         :type tau_tol: float
-        
+
         :returns: A result object containing the results of the simulation.
         :rtype: gillespy2.Results
         """
@@ -162,6 +163,7 @@ def run(self=None, model=None, t=None, number_of_trajectories=1, increment=None,
             )
             self = TauLeapingSolver(model=model, debug=debug, profile=profile)
 
+
         if model is not None:
             log.warning('model = gillespy2.model is deprecated. Future releases '
                         'of GillesPy2 may not support this feature.')
@@ -400,7 +402,11 @@ def __run(self, curr_state, total_time, timeline, trajectory_base, tmpSpecies, l
                     tau_args = [HOR, reactants, mu_i, sigma_i, g_i, epsilon_i, tau_tol, critical_threshold,
                                 self.model, propensities, curr_state[0], curr_time[0], save_time]
 
-                    tau_step = Tau.select(*tau_args)
+                    if self.constant_tau_stepsize is None:
+                        tau_step = Tau.select(*tau_args)
+                        #print(f"t={curr_time[0]} tau={tau_step}")
+                    else:
+                        tau_step = self.constant_tau_stepsize
 
                     prev_start_state = start_state.copy()
                     prev_curr_state = curr_state[0].copy()
diff --git a/test/example_models.py b/test/example_models.py
index f401ec89f..a317fe0d9 100644
--- a/test/example_models.py
+++ b/test/example_models.py
@@ -341,7 +341,7 @@ def create_decay(parameter_values=None):
     """
 
     # Initialize the model.
-    model = Model(name="Example")
+    model = Model(name="Decay")
     # Species
     S = Species(name='Sp', initial_value=100)
     model.add_species([S])
@@ -484,7 +484,7 @@ def create_degradation(model_name="Degradation", parameter_values=None):
 
 
 def create_robust_model(parameter_values=None):
-    model = Model(name="test1")
+    model = Model(name="SBML features")
     model.volume = 1
 
     # Parameters
@@ -532,7 +532,7 @@ def create_multi_firing_event(parameter_values=None):
     """                                                                                                                                                                                                                              
                                                                                                                                                                                                                                      
     # Initialize the model.                                                                                                                                                                                                      
-    model = Model(name="Example")
+    model = Model(name="Multi-Event")
 
     # Species                                                                                                                                                                                                                    
     S = Species(name='Sp', initial_value=100, mode='discrete')