diff --git a/examples/ptmcmc_example.ipynb b/examples/ptmcmc_example.ipynb
new file mode 100644
index 0000000..5141531
--- /dev/null
+++ b/examples/ptmcmc_example.ipynb
@@ -0,0 +1,624 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example usage of `discovery` with the parallel-tempering MCMC sampler `PTMCMC`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "import json, glob, os, re\n",
+    "from jax.tree_util import Partial\n",
+    "import numpy as np\n",
+    "\n",
+    "import discovery as ds\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "%config InlineBackend.figure_format = 'retina'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from discovery import models\n",
+    "from discovery.samplers import ptmcmc_wrapper as dsampler"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Read in pulsar data in the form of feather files. Use the NANOGrav 15-year dataset packaged with `discovery`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datadir = '../data/'\n",
+    "\n",
+    "# Find all .feather files in the directory\n",
+    "feather_files = sorted(glob.glob(os.path.join(datadir, 'v1p1*.feather')))\n",
+    "# Sort the files\n",
+    "feather_files.sort()\n",
+    "\n",
+    "# Loop through the sorted list of .feather files and load each one\n",
+    "psrs = []\n",
+    "for file in feather_files:\n",
+    "    psrs.append(ds.Pulsar.read_feather(file))\n",
+    "\n",
+    "with open('/Users/taylosr8/Research/repos/disco_tests/v1p1_wn_dict.json', 'r') as fp:\n",
+    "    wn_params = json.load(fp)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Set up a `discovery` model the verbose way\n",
+    "\n",
+    "Basic `CURN` or `HD` analysis\n",
+    "- fixed spectral index of 13/3\n",
+    "- intrinsic red noise is power-law with 30 components\n",
+    "- curn has 14 components\n",
+    "- fixed white noise"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tspan = ds.getspan(psrs)\n",
+    "\n",
+    "gamma_common = 13.0/3.0\n",
+    "red_components = 30\n",
+    "common_components = 14\n",
+    "common_type = 'curn'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if gamma_common is not None:\n",
+    "    common_powerlaw = Partial(ds.powerlaw, gamma=gamma_common)\n",
+    "    gamma_common_name = []\n",
+    "else:\n",
+    "    common_powerlaw = ds.powerlaw\n",
+    "    gamma_common_name = ['gw_gamma']\n",
+    "\n",
+    "if common_type == 'curn':\n",
+    "    gl = ds.GlobalLikelihood((ds.PulsarLikelihood([psr.residuals,\n",
+    "                                ds.makenoise_measurement(psr, wn_params), # EFAC, EQUAD white noise\n",
+    "                                ds.makegp_ecorr(psr, wn_params), # ECORR\n",
+    "                                ds.makegp_timing(psr, svd=True), # timing model\n",
+    "                                ds.makegp_fourier(psr, ds.powerlaw, red_components, T=tspan, name='red_noise'), # intrinsic red noise\n",
+    "                                ds.makegp_fourier(psr, common_powerlaw, common_components, T=tspan,\n",
+    "                                                    common=['gw_log10_A']+gamma_common_name, name='gw') # common red noise\n",
+    "                                                    ]) for psr in psrs))\n",
+    "elif common_type == 'hd':\n",
+    "        gl = ds.GlobalLikelihood((ds.PulsarLikelihood([psr.residuals,\n",
+    "                                    ds.makenoise_measurement(psr, wn_params),  # EFAC, EQUAD white noise\n",
+    "                                    ds.makegp_ecorr(psr, wn_params), # ECORR\n",
+    "                                    ds.makegp_timing(psr, svd=True), # timing model\n",
+    "                                    ds.makegp_fourier(psr, ds.powerlaw, red_components, T=tspan, name=\"red_noise\") # intrinsic red noise\n",
+    "                                    ]) for psr in psrs),\n",
+    "                                    ds.makegp_fourier_global(psrs, common_powerlaw,\n",
+    "                                                             ds.hd_orf, common_components,\n",
+    "                                                             T=tspan, name=\"gw\")) # gwb"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The easier way is to use the `models` module to make your likelihood object with keyword arguments."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# curn model with varied gamma\n",
+    "model_curn_vg = models.lhood_maker(psrs, wn_params, gamma_common=None,\n",
+    "                                   common_components=14, red_components=30, common_type='curn')\n",
+    "# curn model with fixed gamma\n",
+    "model_curn_fg = models.lhood_maker(psrs, wn_params, gamma_common=13.0/3.0,\n",
+    "                                   common_components=14, red_components=30, common_type='curn')\n",
+    "# hd model with varied gamma\n",
+    "model_hd_vg = models.lhood_maker(psrs, wn_params, gamma_common=None,\n",
+    "                                   common_components=14, red_components=30, common_type='hd')\n",
+    "# hd model with fixed gamma\n",
+    "model_hd_fg = models.lhood_maker(psrs, wn_params, gamma_common=13.0/3.0,\n",
+    "                                   common_components=14, red_components=30, common_type='hd')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['B1855+09_red_noise_gamma',\n",
+       " 'B1855+09_red_noise_log10_A',\n",
+       " 'B1937+21_red_noise_gamma',\n",
+       " 'B1937+21_red_noise_log10_A',\n",
+       " 'B1953+29_red_noise_gamma',\n",
+       " 'B1953+29_red_noise_log10_A',\n",
+       " 'J0023+0923_red_noise_gamma',\n",
+       " 'J0023+0923_red_noise_log10_A',\n",
+       " 'J0030+0451_red_noise_gamma',\n",
+       " 'J0030+0451_red_noise_log10_A',\n",
+       " 'J0340+4130_red_noise_gamma',\n",
+       " 'J0340+4130_red_noise_log10_A',\n",
+       " 'J0406+3039_red_noise_gamma',\n",
+       " 'J0406+3039_red_noise_log10_A',\n",
+       " 'J0437-4715_red_noise_gamma',\n",
+       " 'J0437-4715_red_noise_log10_A',\n",
+       " 'J0509+0856_red_noise_gamma',\n",
+       " 'J0509+0856_red_noise_log10_A',\n",
+       " 'J0557+1551_red_noise_gamma',\n",
+       " 'J0557+1551_red_noise_log10_A',\n",
+       " 'J0605+3757_red_noise_gamma',\n",
+       " 'J0605+3757_red_noise_log10_A',\n",
+       " 'J0610-2100_red_noise_gamma',\n",
+       " 'J0610-2100_red_noise_log10_A',\n",
+       " 'J0613-0200_red_noise_gamma',\n",
+       " 'J0613-0200_red_noise_log10_A',\n",
+       " 'J0636+5128_red_noise_gamma',\n",
+       " 'J0636+5128_red_noise_log10_A',\n",
+       " 'J0645+5158_red_noise_gamma',\n",
+       " 'J0645+5158_red_noise_log10_A',\n",
+       " 'J0709+0458_red_noise_gamma',\n",
+       " 'J0709+0458_red_noise_log10_A',\n",
+       " 'J0740+6620_red_noise_gamma',\n",
+       " 'J0740+6620_red_noise_log10_A',\n",
+       " 'J0931-1902_red_noise_gamma',\n",
+       " 'J0931-1902_red_noise_log10_A',\n",
+       " 'J1012+5307_red_noise_gamma',\n",
+       " 'J1012+5307_red_noise_log10_A',\n",
+       " 'J1012-4235_red_noise_gamma',\n",
+       " 'J1012-4235_red_noise_log10_A',\n",
+       " 'J1022+1001_red_noise_gamma',\n",
+       " 'J1022+1001_red_noise_log10_A',\n",
+       " 'J1024-0719_red_noise_gamma',\n",
+       " 'J1024-0719_red_noise_log10_A',\n",
+       " 'J1125+7819_red_noise_gamma',\n",
+       " 'J1125+7819_red_noise_log10_A',\n",
+       " 'J1312+0051_red_noise_gamma',\n",
+       " 'J1312+0051_red_noise_log10_A',\n",
+       " 'J1453+1902_red_noise_gamma',\n",
+       " 'J1453+1902_red_noise_log10_A',\n",
+       " 'J1455-3330_red_noise_gamma',\n",
+       " 'J1455-3330_red_noise_log10_A',\n",
+       " 'J1600-3053_red_noise_gamma',\n",
+       " 'J1600-3053_red_noise_log10_A',\n",
+       " 'J1614-2230_red_noise_gamma',\n",
+       " 'J1614-2230_red_noise_log10_A',\n",
+       " 'J1630+3734_red_noise_gamma',\n",
+       " 'J1630+3734_red_noise_log10_A',\n",
+       " 'J1640+2224_red_noise_gamma',\n",
+       " 'J1640+2224_red_noise_log10_A',\n",
+       " 'J1643-1224_red_noise_gamma',\n",
+       " 'J1643-1224_red_noise_log10_A',\n",
+       " 'J1705-1903_red_noise_gamma',\n",
+       " 'J1705-1903_red_noise_log10_A',\n",
+       " 'J1713+0747_red_noise_gamma',\n",
+       " 'J1713+0747_red_noise_log10_A',\n",
+       " 'J1719-1438_red_noise_gamma',\n",
+       " 'J1719-1438_red_noise_log10_A',\n",
+       " 'J1730-2304_red_noise_gamma',\n",
+       " 'J1730-2304_red_noise_log10_A',\n",
+       " 'J1738+0333_red_noise_gamma',\n",
+       " 'J1738+0333_red_noise_log10_A',\n",
+       " 'J1741+1351_red_noise_gamma',\n",
+       " 'J1741+1351_red_noise_log10_A',\n",
+       " 'J1744-1134_red_noise_gamma',\n",
+       " 'J1744-1134_red_noise_log10_A',\n",
+       " 'J1745+1017_red_noise_gamma',\n",
+       " 'J1745+1017_red_noise_log10_A',\n",
+       " 'J1747-4036_red_noise_gamma',\n",
+       " 'J1747-4036_red_noise_log10_A',\n",
+       " 'J1751-2857_red_noise_gamma',\n",
+       " 'J1751-2857_red_noise_log10_A',\n",
+       " 'J1802-2124_red_noise_gamma',\n",
+       " 'J1802-2124_red_noise_log10_A',\n",
+       " 'J1811-2405_red_noise_gamma',\n",
+       " 'J1811-2405_red_noise_log10_A',\n",
+       " 'J1832-0836_red_noise_gamma',\n",
+       " 'J1832-0836_red_noise_log10_A',\n",
+       " 'J1843-1113_red_noise_gamma',\n",
+       " 'J1843-1113_red_noise_log10_A',\n",
+       " 'J1853+1303_red_noise_gamma',\n",
+       " 'J1853+1303_red_noise_log10_A',\n",
+       " 'J1903+0327_red_noise_gamma',\n",
+       " 'J1903+0327_red_noise_log10_A',\n",
+       " 'J1909-3744_red_noise_gamma',\n",
+       " 'J1909-3744_red_noise_log10_A',\n",
+       " 'J1910+1256_red_noise_gamma',\n",
+       " 'J1910+1256_red_noise_log10_A',\n",
+       " 'J1911+1347_red_noise_gamma',\n",
+       " 'J1911+1347_red_noise_log10_A',\n",
+       " 'J1918-0642_red_noise_gamma',\n",
+       " 'J1918-0642_red_noise_log10_A',\n",
+       " 'J1923+2515_red_noise_gamma',\n",
+       " 'J1923+2515_red_noise_log10_A',\n",
+       " 'J1944+0907_red_noise_gamma',\n",
+       " 'J1944+0907_red_noise_log10_A',\n",
+       " 'J1946+3417_red_noise_gamma',\n",
+       " 'J1946+3417_red_noise_log10_A',\n",
+       " 'J2010-1323_red_noise_gamma',\n",
+       " 'J2010-1323_red_noise_log10_A',\n",
+       " 'J2017+0603_red_noise_gamma',\n",
+       " 'J2017+0603_red_noise_log10_A',\n",
+       " 'J2033+1734_red_noise_gamma',\n",
+       " 'J2033+1734_red_noise_log10_A',\n",
+       " 'J2043+1711_red_noise_gamma',\n",
+       " 'J2043+1711_red_noise_log10_A',\n",
+       " 'J2124-3358_red_noise_gamma',\n",
+       " 'J2124-3358_red_noise_log10_A',\n",
+       " 'J2145-0750_red_noise_gamma',\n",
+       " 'J2145-0750_red_noise_log10_A',\n",
+       " 'J2214+3000_red_noise_gamma',\n",
+       " 'J2214+3000_red_noise_log10_A',\n",
+       " 'J2229+2643_red_noise_gamma',\n",
+       " 'J2229+2643_red_noise_log10_A',\n",
+       " 'J2234+0611_red_noise_gamma',\n",
+       " 'J2234+0611_red_noise_log10_A',\n",
+       " 'J2234+0944_red_noise_gamma',\n",
+       " 'J2234+0944_red_noise_log10_A',\n",
+       " 'J2302+4442_red_noise_gamma',\n",
+       " 'J2302+4442_red_noise_log10_A',\n",
+       " 'J2317+1439_red_noise_gamma',\n",
+       " 'J2317+1439_red_noise_log10_A',\n",
+       " 'J2322+2057_red_noise_gamma',\n",
+       " 'J2322+2057_red_noise_log10_A',\n",
+       " 'gw_log10_A']"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Parameter names\n",
+    "model_curn_fg.logL.params"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's test the log-likelihood function at some random position in a uniform prior space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "random_vec = ds.prior.sample_uniform(model_curn_fg.logL.params)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "8191107.167421723\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(model_curn_fg.logL(random_vec))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Time the likelihood while we're at it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "12.3 ms ± 386 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "model_curn_fg.logL(random_vec)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can probably make this faster by jit compiling the log-likelihood function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import jax\n",
+    "jlogl = jax.jit(model_curn_fg.logL)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.66 ms ± 117 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "jlogl(random_vec)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "10 times faster for me!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Prepare the model for `PTMCMC`\n",
+    "\n",
+    "Pass the `discovery` model to the sampler's `InferenceModel` class along with pulsar names. By default it will `jit` compile the log-likelihood and a log-uniform prior."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "disco_infmodel_curn_fg = dsampler.InferenceModel(model_curn_fg, pnames=[p.name for p in psrs])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Time it again to see the interface for the new `get_lnlikelihood` function. Note that there is an intermediate function pass that converts a parameter dictionary to an array, which is what the log-likelihood function of `PTMCMC` expects."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1.62 ms ± 12.8 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%timeit\n",
+    "disco_infmodel_curn_fg.get_lnlikelihood(disco_infmodel_curn_fg.p2x(random_vec))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Setup the sampler\n",
+    "\n",
+    "- Provide an initial position, the parameter dimensionality, and instantiate the sampler object. \n",
+    "- This will also automatically find `groups` of parameters that are most covariant, e.g., intrinsic red noise power-law parameters, and the power-law parameters of a common process. \n",
+    "- Prior draws will also be added into the proposal cycle for intrinsic red noise and the common process."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Adding red noise prior draws...\n",
+      "\n",
+      "Adding GWB uniform distribution draws...\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initial position of the sampler\n",
+    "initial_position = ds.prior.sample_uniform(disco_infmodel_curn_fg.param_names)\n",
+    "# Number of parameters\n",
+    "ndim = len(initial_position)\n",
+    "\n",
+    "sampler = disco_infmodel_curn_fg.setup_sampler(outdir='./example_chain_output/curn_fg/', resume=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following takes less than 3 minutes on a Macbook M3 Pro"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Finished 10.00 percent in 17.186681 s Acceptance rate = 0.49019Adding DE jump with weight 20\n",
+      "Finished 100.00 percent in 161.611604 s Acceptance rate = 0.46567\n",
+      "Run Complete\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Number of samples\n",
+    "n_samples = int(1e5)\n",
+    "\n",
+    "# Run the sampler\n",
+    "samples = sampler.sample(disco_infmodel_curn_fg.p2x(initial_position), n_samples)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Load in the chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "chain = np.loadtxt('./example_chain_output/curn_fg/chain_1.txt')\n",
+    "chain = dict(zip(disco_infmodel_curn_fg.param_names, chain[:,:-4].T))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 432,
+       "width": 588
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(chain['gw_log10_A'][0:]);\n",
+    "plt.xlabel('Count')\n",
+    "plt.ylabel('gw_log10_A')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 433,
+       "width": 580
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "burn = 1000\n",
+    "plt.hist(10**chain['gw_log10_A'][burn:],bins=20);\n",
+    "plt.ylabel('Count')\n",
+    "plt.xlabel('gw_log10_A')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/src/discovery/models.py b/src/discovery/models.py
new file mode 100644
index 0000000..daef476
--- /dev/null
+++ b/src/discovery/models.py
@@ -0,0 +1,51 @@
+from jax.tree_util import Partial
+import discovery as ds
+
+def lhood_maker(psrs, noisedict=None, gamma_common=None, 
+                red_components=30, common_components=14,
+                common_type='curn', array_like=False):
+    """
+    Construct discovery likelihood object from list of pulsar objects.
+    Parameters:
+    - psrs (list): List of pulsar objects.
+    - noisedict (dict, optional): Dictionary containing noise properties for each pulsar. Defaults to None.
+    - gamma_common (float, optional): Common red noise spectral index. Defaults to None.
+    - red_components (int, optional): Number of red noise components. Defaults to 30.
+    - common_components (int, optional): Number of common noise components. Defaults to 14.
+    - common_type (str, optional): Type of common noise model. Defaults to 'curn'.
+    - array_like (bool, optional): Whether to implement `batched` GPs (experimental). Defaults to False. [Not implemented yet]
+
+    Returns:
+    - gl (object): Discovery likelihood object.
+    """
+    
+    tspan = ds.getspan(psrs)
+
+    if gamma_common is not None:
+        common_powerlaw = Partial(ds.powerlaw, gamma=gamma_common)
+        gamma_common_name = []
+    else:
+        common_powerlaw = ds.powerlaw
+        gamma_common_name = ['gw_gamma']
+
+    if common_type == 'curn':
+        gl = ds.GlobalLikelihood((ds.PulsarLikelihood([psr.residuals,
+                                    ds.makenoise_measurement(psr, noisedict),
+                                    ds.makegp_ecorr(psr, noisedict),
+                                    ds.makegp_timing(psr, svd=True),
+                                    ds.makegp_fourier(psr, ds.powerlaw, red_components, T=tspan, name='red_noise'),
+                                    ds.makegp_fourier(psr, common_powerlaw, common_components, T=tspan, 
+                                                      common=['gw_log10_A']+gamma_common_name, name='gw')
+                                                      ]) for psr in psrs))
+    elif common_type == 'hd':
+        gl = ds.GlobalLikelihood((ds.PulsarLikelihood([psr.residuals,
+                                    ds.makenoise_measurement(psr, noisedict),
+                                    ds.makegp_ecorr(psr, noisedict),
+                                    ds.makegp_timing(psr, svd=True),
+                                    ds.makegp_fourier(psr, ds.powerlaw, red_components, T=tspan, name="red_noise")
+                                    ]) for psr in psrs),
+                                    ds.makegp_fourier_global(psrs, common_powerlaw, 
+                                                             ds.hd_orf, common_components, 
+                                                             T=tspan, name="gw"))
+
+    return gl
\ No newline at end of file
diff --git a/src/discovery/samplers/ptmcmc_wrapper.py b/src/discovery/samplers/ptmcmc_wrapper.py
new file mode 100644
index 0000000..61c1507
--- /dev/null
+++ b/src/discovery/samplers/ptmcmc_wrapper.py
@@ -0,0 +1,278 @@
+import os, jax
+import numpy as np
+
+import discovery as ds
+from PTMCMCSampler import PTMCMCSampler as ptmcmc
+
+
+class JumpProposal(object):
+
+    def __init__(self, param_names, empirical_distr=None,
+                 save_ext_dists=False, outdir='./chains'):
+        """Set up some custom jump proposals"""
+
+        self.params = param_names
+
+        # parameter map
+        self.pmap = {}
+        ct = 0
+        for p in self.params:
+            self.pmap[str(p)] = slice(ct, ct+1)
+            ct += 1
+
+    def draw_from_prior(self, x, iter, beta):
+        """Draw a sample from the prior distribution.
+        The function signature is specific to PTMCMCSampler.
+
+        Parameters:
+        - x: The current state of the chain.
+        - iter: The current iteration number.
+        - beta: The current inverse temperature.
+
+        Returns:
+        - q: The new state drawn from the prior distribution.
+        - lqxy: The log probability ratio of the forward-backward jump.
+
+        """
+
+        q = x.copy()
+        lqxy = 0
+
+        # randomly choose parameter
+        param = np.random.choice(self.params)
+
+        q[self.pmap[str(param)]] = list(ds.prior.sample_uniform([param]).values())
+
+        # forward-backward jump probability
+        lqxy += 0
+
+        return q, float(lqxy)
+
+    def draw_from_red_prior(self, x, iter, beta):
+        """
+        Draw a sample from the red noise prior distribution.
+
+        Parameters:
+        - x: numpy.ndarray
+            The current state of the parameters.
+        - iter: int
+            The current iteration number.
+        - beta: float
+            The inverse temperature parameter.
+
+        Returns:
+        - q: numpy.ndarray
+            The new state of the parameters after drawing from the red noise prior.
+        - lqxy: float
+            The log of the forward-backward jump probability ratio.
+
+        """
+
+        q = x.copy()
+        lqxy = 0
+
+        signal_name = 'red_noise'
+        red_pars = [p for p in self.params if signal_name in p]
+
+        # draw parameter from signal model
+        param = np.random.choice(red_pars)
+        q[self.pmap[str(param)]] = list(ds.prior.sample_uniform([param]).values())
+
+        # forward-backward jump probability
+        lqxy += 0
+
+        return q, float(lqxy)
+
+    def draw_from_gwb_log_uniform_distribution(self, x, iter, beta):
+        """
+        Draws a sample from the log-uniform distribution for the GWB.
+
+        Parameters:
+        - x: The current state of the parameters.
+        - iter: The current iteration number.
+        - beta: The inverse temperature parameter.
+
+        Returns:
+        - q: The new state of the parameters after the draw.
+        - lqxy: The log of the forward-backward jump probability ratio.
+        """
+
+        q = x.copy()
+        lqxy = 0
+
+        # draw parameter from signal model
+        param = [p for p in self.params
+                 if ('gw' in p and 'log10_A' in p)][0]
+
+        q[self.pmap[str(param)]] = list(ds.prior.sample_uniform([param]).values())
+
+        # forward-backward jump probability
+        lqxy += 0
+
+        return q, float(lqxy)
+
+
+class InferenceModel(object):
+    """
+    A class representing an inference model.
+    Parameters:
+    - model: The model object.
+    - pnames: A list of parameter names.
+
+    Methods:
+    - __init__(self, model, pnames=None): Initializes the InferenceModel object.
+    - x2p(self, x): Converts a list of values to a dictionary of parameter-value pairs.
+    - p2x(self, p): Converts a dictionary of parameter-value pairs to a list of values.
+    - get_parameter_groups(self): Utility function to get parameter groupings for sampling.
+    - setup_sampler(self, outdir='chains', resume=False, empirical_distr=None, groups=None, loglkwargs={}, logpkwargs={}): Sets up the sampler for MCMC sampling.
+    """
+
+    def __init__(self, model, pnames=None):
+        """
+        Initializes an instance of the `disco_ptmcmc` class.
+        Parameters:
+        - model: The model object.
+        - pnames: A list of pulsar names.
+        Returns:
+        None
+        """
+
+        self.pnames = pnames
+        self.param_names = model.logL.params
+
+        loglike = model.logL
+        logprior = ds.prior.makelogprior_uniform(self.param_names,
+                                                 ds.prior.priordict_standard)
+
+        jlogl = jax.jit(loglike)
+        jlogp = jax.jit(logprior)
+
+        self.get_lnlikelihood = lambda x: float(jlogl(self.x2p(x)))
+        self.get_lnprior = lambda x: float(jlogp(self.x2p(x)))
+
+    def x2p(self, x):
+        """
+        Converts a list of parameter values `x` to a dictionary representation.
+
+        Args:
+            x (list): A list of parameter values.
+
+        Returns:
+            dict: A dictionary representation of the parameter values, where the keys are the parameter names and the values are the corresponding values from `x`.
+        """
+        # does not handle vector parameters
+        return {par: val for par, val in zip(self.param_names, x)}
+
+    def p2x(self, p):
+        """
+        Convert a dictionary of values to a NumPy array.
+
+        Parameters:
+            p (dict): A dictionary containing values.
+
+        Returns:
+            numpy.ndarray: A NumPy array containing the values from the dictionary.
+        """
+        return np.array(list(p.values()), 'd')
+
+    def get_parameter_groups(self):
+        """Utility function to get parameter groupings for sampling."""
+        params = self.param_names
+        ndim = len(params)
+        groups = [list(np.arange(0, ndim))]
+
+        # get global and individual parameters
+        gpars = [p for p in params if 'gw' in p or 'curn' in p]
+        ipars = [p for p in params if p not in gpars]
+        if gpars:
+            # add a group of all global parameters
+            groups.append([params.index(gp) for gp in gpars])
+        if ipars:
+            #groups.append([params.index(ip) for ip in ipars])
+            groups += [[params.index(ip) for ip in ipars if p in ip]
+                       for p in self.pnames]
+
+        return groups
+
+    def setup_sampler(self, outdir='chains', resume=False,
+                      empirical_distr=None, groups=None,
+                      loglkwargs={}, logpkwargs={}):
+        """
+        Set up the sampler for performing MCMC (Markov Chain Monte Carlo) sampling.
+
+        Parameters:
+        - outdir (str): The output directory for saving the chains. Default is 'chains'.
+        - resume (bool): Whether to resume from a previous run. Default is False.
+        - empirical_distr (None or str): The path to the empirical distribution file. Default is None.
+        - groups (None or list): The parameter groups for the sampler. Default is None.
+        - loglkwargs (dict): Additional keyword arguments for the log-likelihood function. Default is an empty dictionary.
+        - logpkwargs (dict): Additional keyword arguments for the log-prior function. Default is an empty dictionary.
+
+        Returns:
+        - sampler: The initialized PTMCMCSampler object.
+        """
+
+        # dimension of parameter space
+        ndim = len(self.param_names)
+
+        # initial jump covariance matrix
+        if os.path.exists(outdir+'/cov.npy') and resume:
+            cov = np.load(outdir+'/cov.npy')
+
+            # check that the one we load is the same shape as our data
+            cov_new = np.diag(np.ones(ndim) * 1.0**2)
+            if cov.shape != cov_new.shape:
+                msg = 'The covariance matrix (cov.npy) in the output folder is '
+                msg += 'the wrong shape for the parameters given. '
+                msg += 'Start with a different output directory or '
+                msg += 'change resume to False to overwrite the run that exists.'
+
+                raise ValueError(msg)
+        else:
+            cov = np.diag(np.ones(ndim) * 1.0**2)  # used to be 0.1
+
+        # parameter groupings
+        if groups is None:
+            groups = self.get_parameter_groups()
+
+        sampler = ptmcmc.PTSampler(ndim, self.get_lnlikelihood, self.get_lnprior, cov,
+                                   groups=groups, outDir=outdir, resume=resume,
+                                   loglkwargs=loglkwargs, logpkwargs=logpkwargs)
+
+        # additional jump proposals
+        jp = JumpProposal(param_names=self.param_names, empirical_distr=None,
+                          save_ext_dists=False, outdir=outdir)
+        sampler.jp = jp
+
+        # always add draw from prior
+        sampler.addProposalToCycle(jp.draw_from_prior, 5)
+
+        # try adding empirical proposals
+        #if empirical_distr is not None:
+        #    print('Adding empirical proposals...\n')
+        #    sampler.addProposalToCycle(jp.draw_from_empirical_distr, 25)
+
+        # Red noise prior draw
+        if any('red_noise' in s for s in self.param_names):
+            print('Adding red noise prior draws...\n')
+            sampler.addProposalToCycle(jp.draw_from_red_prior, 10)
+
+        # GWB uniform distribution draw
+        if np.any([('gw' in par and 'log10_A' in par) for par in self.param_names]):
+            print('Adding GWB uniform distribution draws...\n')
+            sampler.addProposalToCycle(jp.draw_from_gwb_log_uniform_distribution, 10)
+
+        # free spectrum prior draw
+        #if np.any(['log10_rho' in par for par in self.param_names]):
+        #    print('Adding free spectrum prior draws...\n')
+        #    sampler.addProposalToCycle(jp.draw_from_gw_rho_prior, 25)
+
+        # Prior distribution draw for parameters named GW
+        #if any([str(p).split(':')[0] for p in list(self.params) if 'gw' in str(p)]):
+        #    print('Adding gw param prior draws...\n')
+        #    sampler.addProposalToCycle(jp.draw_from_par_prior(
+        #        par_names=[str(p).split(':')[0] for
+        #                   p in list(self.params)
+        #                  if 'gw' in str(p)]), 10)
+
+        return sampler
\ No newline at end of file