diff --git a/doframework/api.py b/doframework/api.py
index 9c71191..ae2fd36 100644
--- a/doframework/api.py
+++ b/doframework/api.py
@@ -32,7 +32,8 @@
         'mock',
         'after_idle_for',
         'rayvens_logs',
-        'alg_num_cpus'
+        'alg_num_cpus',
+        'data_num_cpus'
         ]
     )
 
@@ -194,20 +195,20 @@ def _number_of_iterations(process_input, args, process_type):
 def _get_extra_input(input_name, process_type, configs, args, buckets):
     try:
         if process_type == 'input':
-            extra = {}
+            extra = {'mock': args.mock}
         elif process_type == 'objective':
-            extra = {}
+            extra = {'mock': args.mock}
         elif process_type == 'data':
             files = files_from_data(input_name)
             storage = Storage(configs)
             objective = storage.get(buckets['objectives_dest'],files['objective'])
-            extra = {'objective': json.load(objective)}
+            extra = {'num_cpus': args.data_num_cpus, 'objective': json.load(objective), 'mock': args.mock}
         elif process_type == 'solution':
             files = files_from_solution(input_name)
             storage = Storage(configs)
             objective = storage.get(buckets['objectives_dest'],files['objective'])
             data = storage.get(buckets['data_dest'],files['data'])
-            extra = {'is_mcmc': args.mcmc, 'objective': json.load(objective), 'data': pd.read_csv(data)}
+            extra = {'is_mcmc': args.mcmc, 'objective': json.load(objective), 'data': pd.read_csv(data), 'mock': args.mock}
         else:
             extra = None
         return extra
@@ -222,10 +223,19 @@ def _get_extra_input(input_name, process_type, configs, args, buckets):
 
 def _process(process_type, configs, args, buckets, **kwargs):
     def proc(f):
-        
-        @ray.remote(num_cpus=1)
-        def f_dist(*args,**kwargs):
-            return f(*args,**kwargs)
+
+        if process_type == 'data':
+            @ray.remote(num_cpus=args.data_num_cpus)
+            def f_dist(*args,**kwargs):
+                return f(*args,**kwargs)
+        elif process_type == 'solution':
+            @ray.remote(num_cpus=args.alg_num_cpus)
+            def f_dist(*args,**kwargs):
+                return f(*args,**kwargs)
+        else:
+            @ray.remote(num_cpus=1)
+            def f_dist(*args,**kwargs):
+                return f(*args,**kwargs)
 
         def inner(context, event):
             
@@ -253,12 +263,8 @@ def inner(context, event):
 
                 extra = _get_extra_input(input_name, process_type, configs, args, buckets)
                 assert extra is not None, 'Extra input is None for event {}.'.format(input_name)
-                if args.logger: 
-                    if extra:
-                        print('({}) INFO ... Process working on event {} uses extra input {}.'.format(process_type,input_name,list(extra.keys())))
-                    else:
-                        print('({}) INFO ... Process working on event {} does not require extra input.'.format(process_type,input_name))
-                extra = {**extra,**kwargs,**configs,**{'mock': args.mock}}
+                
+                extra = {**extra,**kwargs,**configs}
 
                 if args.distribute:
                     _ = [f_dist.remote(context, process_input, input_name, **extra) for _ in range(n)]
@@ -311,8 +317,9 @@ def run(generate_user_solution, configs_file, **kwargs):
     after_idle_for = kwargs['after_idle_for'] if 'after_idle_for' in kwargs else 200
     rayvens_logs = kwargs['rayvens_logs'] if 'rayvens_logs' in kwargs else False
     alg_num_cpus = int(kwargs['alg_num_cpus']) if 'alg_num_cpus' in kwargs else 1
+    data_num_cpus = int(kwargs['data_num_cpus']) if 'data_num_cpus' in kwargs else 1
 
-    args = Args(objectives, datasets, feasibility_regions, run_mode, distribute, mcmc, logger, mock, after_idle_for, rayvens_logs, alg_num_cpus)
+    args = Args(objectives, datasets, feasibility_regions, run_mode, distribute, mcmc, logger, mock, after_idle_for, rayvens_logs, alg_num_cpus, data_num_cpus)
 
     if args.run_mode == 'operator':
         ray.init(address='auto')
@@ -356,7 +363,7 @@ def generate_datasets(context, process_input, input_name, **kwargs):
         else:
             print('({}) ERROR ... generated dataset {} not published to context. Either `s3` or `local` missing from cofnigs or both feature.'.format('objective',generated_file))
 
-    @ray.remote(num_cpus=args.alg_num_cpus)
+    @ray.remote(num_cpus=1)
     @_process('data', configs, args, buckets, **kwargs)
     def generate_solutions(context, process_input, input_name, **kwargs):
         solution, generated_file = generate_user_solution(process_input, input_name, **kwargs)
diff --git a/doframework/core/hit_and_run.py b/doframework/core/hit_and_run.py
new file mode 100644
index 0000000..ae8062d
--- /dev/null
+++ b/doframework/core/hit_and_run.py
@@ -0,0 +1,504 @@
+#
+# Copyright IBM Corporation 2022
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from itertools import islice, combinations
+from typing import Optional
+from functools import partial
+# from multiprocess import Pool
+from ray.util.multiprocessing import Pool
+
+import numpy as np
+import numpy.linalg as la
+from scipy.stats import norm, uniform
+from scipy.stats import multivariate_normal
+from scipy.spatial import ConvexHull, convex_hull_plot_2d
+
+def box_sample(box_lows, box_highs, d, N: int=1) -> np.array:
+    '''
+    Sample N points of dimension d in a box whose lower bounds are given by box_lows and whose upper bounds are given by box_highs.
+    '''
+    
+    return np.random.uniform(box_lows,box_highs,(N,d))
+
+def scale(x: np.array, points: np.array, normals: np.array):
+    
+    shifts = x.flatten() - points
+    dists = [abs(normal @ shift.T) for normal, shift in zip(normals, shifts)]
+    r = min(dists)
+    
+    return min([r,1])
+
+def sphere_sample(d: int, N: int=1, r: float=1.):
+    
+    us = np.random.normal(size=(N,d))
+    norms = la.norm(us,axis=1)[:,None]
+    
+    return r * (us/norms) 
+
+def ball_sample(d: int, N: int=1, R: float=1.):
+    
+    us = np.random.normal(size=(N,d))
+    norms = la.norm(us,axis=1)[:,None]
+    rs = R*np.power(np.random.uniform(size=N),1/d)[:,None]
+    
+    return rs * (us/norms) 
+
+def projection(x, x1, x2) -> np.array:
+    '''
+    Produce the projection of point x onto the line between x1 and x2.
+    
+            Parameters:
+                    x (np.array): point.
+                    x1 (np.array): line point.
+                    x2 (np.array): line point.
+                    
+            Returns:
+                    projection point.
+                    
+    '''    
+    
+    nhat = (x2-x1)/np.sqrt((x2-x1)@(x2-x1).T)
+    
+    return x1 + ((x-x1)@nhat.T)*nhat
+
+def chord_intersection(x: np.array, ray: np.array, A: np.array):
+    '''
+    Produce the two intersection points of a convex polytope with a line.
+    The line is given by a point x and a unit vector ray in the line direction.
+    The convex polytope is given by the matrix A such that Ax <= 0 defines the convex polytope. 
+    Each row of A[:,:-1] is a normal to a face of the convex polytope.
+    We assume x is inside the given polytope!
+    
+            Parameters:
+                    x (np.array): point.
+                    ray (np.array): direction.
+                    A (np.array): matrix defining a convex polytope Ax <= 0.
+                    
+            Returns:
+                    x_minus, x_plus the two intersection points.
+                    
+    '''    
+    
+    pos_mask = A[:,:-1] @ ray.T >= 0
+    pos_hull = A[pos_mask]
+    ts_plus = ((-pos_hull[:,-1:] - (pos_hull[:,:-1]@x.T)[:,None]) / (pos_hull[:,:-1]@ray.T)[:,None]).min()
+
+    neg_mask = A[:,:-1] @ ray.T <= 0
+    neg_hull = A[neg_mask]
+    ts_minus = ((-neg_hull[:,-1:] - (neg_hull[:,:-1]@x.T)[:,None]) / (neg_hull[:,:-1]@ray.T)[:,None]).max()
+
+    x_minus = ts_minus*ray+x
+    x_plus = ts_plus*ray+x
+    
+    return x_minus, x_plus
+
+def get_hull(points: np.array):
+
+    hull = ConvexHull(points,qhull_options='QJ')
+    vertices = points[hull.vertices,:]
+    simplices = points[hull.simplices,:]
+    
+    return hull, vertices, simplices
+
+def _singular(points: np.array):
+    
+    M = points.T
+    U, S, _ = la.svd(M,full_matrices=False)
+
+    svalmax = S[0]
+    svecmax = U[:,0][:,None]
+    svalmin = S[-1]    
+    svecmin = U[:,-1][:,None]
+
+    return svalmax, svecmax, svalmin, svecmin
+
+def _tranformation(svalmax: float, svecmax: np.array, d: int):
+    
+    return np.eye(d) + (1/svalmax-1) * svecmax@svecmax.T
+
+def rounding(points: np.array, threshold: float=0.1, M: int=500, tol: float=1e-8):
+    '''
+    Round a convex polytope. The polytope is given as the convex hull of points.
+    We assume the polytope contains a the unit ball around the origin.
+    Rounding will terminate once the diff between the high and low singular values of points is below 
+    the threshold times the high singular value. The lower the ratio (sval_high-sval_low)/sval_high,
+    the rounder we consider the polytope to be.
+    
+            Parameters:
+                    points (np.array): points.
+                    threshold (float): stopping condition for rounding (default: 10% or 0.1).
+                    M (int): terminate after M rounding attempts (default: 500).
+                    
+            Returns:
+                    round_points: the new points after rounding.
+                    T: the rounding linear transformation. Reverse-apply with round_points@la.inv(T).
+                    
+    '''    
+
+    svalmax, svecmax, svalmin, _ = _singular(points)
+
+    d = points.shape[-1]
+    T = np.eye(d)
+    round_points = points
+    attempts = 1
+
+    while (svalmax-svalmin)/svalmax > threshold:
+        A = _tranformation(svalmax, svecmax, d)
+        round_points, T = (A@round_points.T).T, A@T
+        svalmax, svecmax, svalmin, _ = _singular(round_points)
+        if attempts>M:
+            print(f'Reached max {M} rounding attempts. Rounding failed to reach the rounding threshold {threshold:.3f}.')
+            break
+        else:
+            attempts += 1
+        
+    assert np.all(np.isclose((T@(points).T).T,round_points,atol=tol)), \
+    'Something went wrong ... transformation T should produce rounded points from initial points.'
+    
+    return round_points, T
+
+def in_domain(xs, A: np.array, R: Optional[float]=None, **kwargs) -> np.array:
+    '''
+    Check whether xs are inside the intersection of a convex polytope and a ball of radius R.
+    The convex polytope is given by the matrix A such that Ax<=0 defines it.
+    
+            Parameters:
+                    xs (np.array): points.
+                    A (np.array): matrix defining a convex polytope Ax <= 0.
+                    R (float): radius.
+                    
+            Returns:
+                    a boolean numpy array that indicates whether the points are inside the polytope.
+                    
+    '''    
+    
+    tol = kwargs['tol'] if 'tol' in kwargs else 1e-8
+    N = xs.shape[0]
+    multi = A @ np.vstack([xs.T,np.ones(N)[None,:]])
+    multi = np.where(np.isclose(multi,0,atol=tol),0,multi)
+    
+    inside = np.all(multi <= 0, axis=0) * (la.norm(xs,axis=1) <= R) if R else np.all(multi <= 0, axis=0)
+    
+    return inside 
+
+def _warm_yield(origin: np.array, sigma_sq: float):
+    
+    d = origin.shape[-1]
+    
+    while True:
+        
+        yield multivariate_normal(mean=origin.flatten(), cov=sigma_sq*np.eye(d)).rvs()
+
+def warm_start(mu: np.array, A: np.array, sigma_sq: float, N: int=1, **kwargs) -> np.array:
+    '''
+    Sample a spherical Gaussian inside a convex polytope by exclusion.
+    The convex polytope is given by the matrix A such that Ax<=0 defines it.
+    The spherical gaussian is centered at mu with variance sigma_sq.
+    
+            Parameters:
+                    mu (np.array): center of spherical Gaussian.
+                    A (np.array): matrix defining a convex polytope Ax <= 0.
+                    sigma_sq (float): variance of spherical Gaussian.
+                    
+            Returns:
+                    numpy array of samples.
+                    
+    '''    
+            
+    return np.array(list(islice(filter(lambda x: in_domain(x[None,:],A,**kwargs)[0],_warm_yield(mu,sigma_sq)),N)))
+
+def _chord_interval(mu: np.array, x1: np.array, x2: np.array) -> tuple:
+    '''
+    Project line passing through x1 and x2 to the reals with mu at the origin.
+    mu is assumed to be a point on the line.
+    
+            Parameters:
+                    mu (np.array): point.
+                    x1 (np.array): point on chord end.
+                    x2 (np.array): point on chord end.
+
+                    
+            Returns:
+                    a 2-tuple (a,b) indicating the real coordinates of x1 and x2 projections relative to mu.
+                    
+    '''
+    
+    if (x2-mu)@(mu-x1).T>0: # mu between x1 and x2
+        a, b = -la.norm(mu-x1), la.norm(x2-mu)
+        
+    elif (x2-x1)@(x1-mu).T>0: # x1 between mu and x2
+        a, b = la.norm(x1-mu), la.norm(x2-mu)
+        
+    elif (x1-x2)@(x2-mu).T>0: # x2 between mu and x1
+        a, b = -la.norm(x1-mu), -la.norm(x2-mu)
+        
+    else:
+        a, b = None, -la.norm(x2-mu)
+                    
+    return a, b
+    
+def chord_sample(mu: np.array, x1: np.array, x2: np.array, **kwargs):    
+    '''
+    Sample a single point along a chord with end points x1 and x2. 
+    The point mu is located on a line defined by x1 and x2 (not necessarily in between, i.e., on the chord).
+    When variance (sigma_sq) is provded in kwargs, point is sampled from a 1D Gaussian along the chord centered at mu.
+    Otherwise, point is sampled uniformaly along the chord.
+    
+            Parameters:
+                    mu (np.array): point.
+                    x1 (np.array): point on chord end.
+                    x2 (np.array): point on chord end.
+
+                    
+            Returns:
+                    a single sample (np.array) from the chord.
+                    
+    '''
+                
+    (a,b) = _chord_interval(mu,x1,x2)        
+    chord_length = b - a # must be positive!
+    chord_normal = (x2-x1)/ chord_length
+        
+    if 'sigma_sq' in kwargs: # sample from gaussian projected on chord
+                
+        sigma_sq = kwargs['sigma_sq']
+        chord_gaussian = norm(loc=0.0, scale=np.sqrt(sigma_sq))
+        
+        if chord_length > 2*np.sqrt(sigma_sq):
+            c = chord_gaussian.rvs()
+            accept = c<=b and c>=a
+            y = mu + c*chord_normal
+        else:
+            c = box_sample([a,0],[b,1],2).flatten()
+            accept = chord_gaussian.pdf(c[0]) >= c[1]
+            y = mu + c[0]*chord_normal
+            
+    else: # sample uniformly from chord
+        
+        chord_uniform = uniform(loc=a, scale=chord_length)    
+        
+        c = chord_uniform.rvs()
+        accept = True
+        y = mu + c*chord_normal
+                            
+    return y, accept
+
+def _hit_and_run_single(origin: np.array, A: np.array, delta: float, T: int=1, tol: float=1e-8, dist_dict: dict={}) -> np.array:
+    '''
+    Sample a single point from a spherical Gaussian or the uniform distribution restricted to a convex polytope given by Ax<=0.
+    The spherical gaussian is centered at origin with variance sigma_sq given in dist_dict.
+    When no variance (sigma_sq) is provded in dist_dict, point is sampled uniformaly.
+    Sampling is done using the Hit & Run algorithm following Ben Cousins in Efficient High-dimensional Sampling and Integration (PhD Thesis, 2017).
+    
+            Parameters:
+                    origin (np.array): center of spherical Gaussian.
+                    A (np.array): matrix defining a convex polytope Ax <= 0.
+                    delta (float): variance of spherical Gaussian for warm start.
+                    T (int): random walk mixing time (default: 1).
+                    tol (float): tolerance level to near zero results (default: 1e-8).
+                    dist_dict (dict): dictionary containing distribution info (default: {}, i.e., sample uniformaly).
+
+                    
+            Returns:
+                    a single sample (np.array).
+                    
+    '''
+    
+    np.random.seed() # prevent sampling from same random state on different pool threads
+    
+    x = warm_start(origin,A,delta,tol=tol).flatten()
+    d = origin.shape[-1]
+    
+    count = 1
+
+    while count<=T:
+
+        ray = sphere_sample(d).flatten()
+        x1, x2 = chord_intersection(x,ray,A)
+        mu = projection(origin,x1,x2)
+
+        try:
+            if 'sigma_sq' in dist_dict:                    
+                y, accept = chord_sample(mu,x1,x2,sigma_sq=dist_dict['sigma_sq'])
+            else:
+                y, accept = chord_sample(mu,x1,x2)
+        except:
+            continue
+
+        if accept:
+            x = y   
+            count += 1
+    
+    return x
+
+def hit_and_run(N: int,
+                origin: np.array,
+                A: np.array, 
+                T: int=1,
+                delta: float=0.1,
+                tol: float=1e-8,
+                **kwargs):
+
+    num_cpus = kwargs['num_cpus'] if 'num_cpus' in kwargs else 1
+
+    dist_tuples = tuple({'sigma_sq': kwargs['sigma_sq']} for _ in range(N)) if 'sigma_sq' in kwargs else tuple({} for _ in range(N))
+
+    with Pool(processes=num_cpus) as pool:
+
+        res = pool.map_async(partial(_hit_and_run_single,origin,A,delta,T,tol), dist_tuples)
+        xs = res.get()
+
+    return np.array(xs)
+
+def hit_and_run_square_test(N: int=5000, T: int=20, sigma_sq: float=1., L: float=10.0, delta: float=0.1, 
+                            linspace_num: int=500, coord_projection: int=0, figsize: tuple=(7,8), num_cpus: int=4, tol: float=1e-8):
+    '''
+    Test the Hit & Run algorithm by sampling in a large box a relatively small spherical Gaussian.
+    Multivariate normality is tested with the Henze-Zikler test.
+    When no variance (sigma_sq) is provded in dist_dict, point is sampled uniformaly.
+    Sampling is done using the Hit & Run algorithm following Ben Cousins in Efficient High-dimensional Sampling and Integration (PhD Thesis, 2017).
+    
+            Parameters:
+                    origin (np.array): center of spherical Gaussian.
+                    A (np.array): matrix defining a convex polytope Ax <= 0.
+                    delta (float): variance of spherical Gaussian for warm start.
+                    T (int): random walk mixing time (default: 1).
+                    tol (float): tolerance level to near zero results (default: 1e-8).
+                    dist_dict (dict): dictionary containing distribution info (default: {}, i.e., sample uniformaly).
+
+                    
+            Returns:
+                    a single sample (np.array).
+                    
+    '''
+
+    import pingouin as pg # Henze-Zikler test of multivariate normality
+    import matplotlib.pyplot as plt
+    from scipy.stats import gaussian_kde
+    
+    points = np.array([[-L,-L],[-L,L],[L,-L],[L,L]])
+    d = points.shape[-1]
+
+    hull = ConvexHull(points,qhull_options='QJ')
+    vertices = points[hull.vertices,:]
+    origin = np.average(vertices,axis=0)[None,:]
+
+    X = hit_and_run(N,origin,hull.equations,T,delta,sigma_sq=sigma_sq,num_cpus=num_cpus,tol=tol)
+    henze_zirkler_test = pg.multivariate_normality(X, alpha=.05)
+    print('Henze-Zirkler multivariate normality sample test:',henze_zirkler_test.normal)
+
+    x = X[-1,:]
+    ray = sphere_sample(d).flatten()
+    x1, x2 = chord_intersection(x,ray,hull.equations)
+    mu = projection(origin,x1,x2)
+    interval = np.vstack([x1,x2])
+    y, accept = chord_sample(mu, x1, x2, sigma_sq=sigma_sq)
+
+    xproj = X[:,coord_projection]
+    xmin = xproj.min()
+    xmax = xproj.max()
+    kde = gaussian_kde(xproj)
+    xs = np.linspace(xmin,xmax,linspace_num)
+    density = kde.pdf(xs)
+
+    fig = plt.figure(figsize=figsize)
+    
+    ax1 = fig.add_subplot(2,1,1)
+    ax1.plot(xs,density,label='H&R Samples')
+    ax1.plot(xs,norm(loc=0.,scale=sigma_sq**(0.5)).pdf(xs),label='Gaussian Samples')
+    ax1.set_title(f'Hit & Run vs. Spherical Gaussian Samples with STD {sigma_sq**(0.5)} ({N} samples projected onto the {coord_projection}-th coordinate)')
+    ax1.legend(loc='upper right')
+
+    ax2 = fig.add_subplot(2,1,2)
+    convex_hull_plot_2d(hull, ax=ax2)
+    ax2.plot(np.atleast_2d(interval)[:,0],np.atleast_2d(interval)[:,1],c='pink',label='chord')
+    ax2.scatter(np.atleast_2d(interval)[:,0],np.atleast_2d(interval)[:,1],s=60,c='pink')
+    ax2.scatter(np.atleast_2d(X)[:,0],np.atleast_2d(X)[:,1],s=20,c='y',alpha=0.3,label='Xs')
+    ax2.scatter(np.atleast_2d(origin)[:,0],np.atleast_2d(origin)[:,1],s=80,c='black',label='origin')
+    ax2.scatter(np.atleast_2d(y)[:,0],np.atleast_2d(y)[:,1],s=40,c='r',label='y')
+    ax2.scatter(np.atleast_2d(mu)[:,0],np.atleast_2d(mu)[:,1],s=40,c='b',label='mu')
+    ax2.set_title(f'Hit & Run sample along a chord (sample accepted={accept})')
+    ax2.grid()
+    ax2.legend(loc='lower right')  
+    
+    plt.show()
+
+def plot_polytope(hull: ConvexHull, origin: np.array=np.array([]), X: np.array=np.array([]), figsize: tuple=(7,7), elevation: int=25, azimute: int=150, **kwargs):
+
+    import matplotlib.pyplot as plt
+    
+    points = hull.points
+    d = points.shape[-1]
+    plot_sample = False
+    
+    if X.size>0:
+        assert X.shape[-1]==d, f'Dimension mismatch between samples of dimension {X.shape[-1]} and origin of dimension {d}.'
+        plot_sample = True
+        
+    plot_origin = origin.size>0
+        
+    if d == 2:        
+
+        fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot()
+        convex_hull_plot_2d(hull, ax=ax)
+        
+        if plot_sample:
+            ax.scatter(np.atleast_2d(X)[:,0],np.atleast_2d(X)[:,1],s=20,c='y',alpha=0.3,label='Xs')
+            
+        if plot_origin:
+            ax.scatter(np.atleast_2d(origin)[:,0],np.atleast_2d(origin)[:,1],s=80,c='black',label='origin')
+
+        ax.scatter(np.atleast_2d(points)[:,0],np.atleast_2d(points)[:,1],color='b',s=40,label='points')        
+            
+        plt.grid()
+        plt.legend(loc='lower right')
+        
+        if 'xlims' in kwargs:
+            plt.xlim(kwargs['xlims'])
+        if 'ylims' in kwargs:
+            plt.ylim(kwargs['ylims'])
+            
+
+    if d==3:
+
+        fig = plt.figure(figsize=figsize)
+        ax = fig.add_subplot(projection='3d')
+                
+        simplices = points[hull.simplices,:]
+
+        for i,s in enumerate(simplices):
+
+            edges = [np.vstack(e) for e in combinations(s, 2)]
+
+            for j,edge in enumerate(edges):
+                if i+j==0:
+                    ax.plot(edge[:,0],edge[:,1],edge[:,2],color='grey',label='polytope')
+                else:
+                    ax.plot(edge[:,0],edge[:,1],edge[:,2],color='grey')
+
+        if plot_sample:
+            ax.scatter(np.atleast_2d(X)[:,0],np.atleast_2d(X)[:,1],np.atleast_2d(X)[:,2],c='y',s=20,alpha=0.3,label='Xs')
+        if plot_origin:
+            ax.scatter(np.atleast_2d(origin)[:,0],np.atleast_2d(origin)[:,1],np.atleast_2d(origin)[:,2],color='black',s=40,label='origin')  
+        ax.scatter(np.atleast_2d(points)[:,0],np.atleast_2d(points)[:,1],np.atleast_2d(points)[:,2],color='b',s=40,label='points')        
+
+        ax.view_init(elev=elevation, azim=azimute)
+        ax.set_xlabel('X')
+        ax.set_ylabel('Y')
+        ax.set_zlabel('Z')
+        plt.draw()
+        plt.legend()
\ No newline at end of file
diff --git a/doframework/core/pwl.py b/doframework/core/pwl.py
index 1ead8ad..818537e 100644
--- a/doframework/core/pwl.py
+++ b/doframework/core/pwl.py
@@ -1,6 +1,7 @@
 import itertools
 import numpy as np
 from numpy import linalg
+from scipy.stats import gmean
 from scipy.spatial import ConvexHull
 from typing import Callable, Any, List
 from dataclasses import dataclass, field
@@ -45,7 +46,8 @@ def hyperplanePartition(H: np.array,
     n = H.shape[0]
     m = X.shape[0]
     
-    O = O if O.shape[0] else np.ones(n)
+    not_orientation = O.shape[0]
+    O = O if not_orientation else np.ones(n)
 
     SFirst = np.tile(H[:,:-1,:],(m,1,1,1))
     SLast = np.tile(np.tile(H[:,-1,:],(1,d)).reshape(n,d,d),(m,1,1,1)) 
@@ -54,7 +56,11 @@ def hyperplanePartition(H: np.array,
     
     dets = dets/scale_factor
 
-    return np.sign(np.where(np.isclose(dets,0.0,atol=tolerance),0.0,dets)*O)
+    # adjust tolerance only for orientation computation to ensure we don't get 0.
+    # when calculating orientation, each column contains a single signed volume value entry.
+    tol = tolerance if not_orientation else max(gmean(np.abs(dets[np.nonzero(dets)]))/10,tolerance)
+
+    return np.sign(np.where(np.isclose(dets,0.0,atol=tol),0.0,dets)*O)
 
 def argopt(arrs: List[np.array], key: Callable[..., Any]) -> tuple:
     '''
diff --git a/doframework/core/sampler.py b/doframework/core/sampler.py
index 5f2e95b..9c0f3b8 100644
--- a/doframework/core/sampler.py
+++ b/doframework/core/sampler.py
@@ -14,30 +14,21 @@
 # limitations under the License.
 #
 
+import itertools as it
+import logging
 from typing import Optional, List
+
 import numpy as np
+import numpy.linalg as la
 from scipy.stats import rv_continuous
 from scipy.stats import norm, uniform
-import itertools as it
+from scipy.stats import gmean
+from scipy.spatial import ConvexHull
 
-from doframework.core.pwl import PWL, Polyhedron
-
-def sample_f_values(f_range: List, N: int=1) -> np.array:
-    '''
-    Sample function values from a given range.
-    
-            Parameters:
-                    f_range (List): range of function values.
-                    N (int): sample size.
-                    
-            Returns:
-                    Sample of size N from uniform distribution defined by f_range.
-                    
-    '''
-    
-    return uniform(f_range[0],f_range[1]-f_range[0]).rvs(N)
+from doframework.core.pwl import PWL
+from doframework.core.hit_and_run import scale, get_hull, in_domain, rounding, hit_and_run
 
-def X_hypothesis_sampler(hypothesis, I: int, weights: list, **kwargs):
+def X_hypothesis_sampler_legacy(hypothesis, I: int, weights: list, **kwargs):
     
     while True:
         
@@ -45,7 +36,7 @@ def X_hypothesis_sampler(hypothesis, I: int, weights: list, **kwargs):
     
         yield np.atleast_2d(hypothesis(**{k: v[i] for k,v in kwargs.items()}).rvs())
 
-def X_sampler(f: PWL, hypothesis, N: int, weights: list, **kwargs):
+def X_sampler_legacy(f: PWL, hypothesis, N: int, weights: list, **kwargs):
     '''
     Sample from a mixed distribution given a hypothesis. Samples will be in Supp(f).
     
@@ -68,19 +59,34 @@ def X_sampler(f: PWL, hypothesis, N: int, weights: list, **kwargs):
     assert abs(sum(weights)-1)<epsilon, 'Weights must add up to 1.'
             
     return np.concatenate(list(it.islice(filter(lambda x: f.isin(x)[0],
-                                                X_hypothesis_sampler(hypothesis,
+                                                X_hypothesis_sampler_legacy(hypothesis,
                                                                     Is[0],
                                                                     weights,
                                                                     **kwargs)),N)))
 
-def D_sampler(f: PWL, hypothesis, N: int, weights: list, noise: float, **kwargs):
+def D_sampler_legacy(f: PWL, hypothesis, N: int, weights: list, noise: float, **kwargs):
     
-    X = X_sampler(f,hypothesis,N,weights,**kwargs)
+    X = X_sampler_legacy(f,hypothesis,N,weights,**kwargs)
     y = f.evaluate(X) + norm(loc=0,scale=noise).rvs(size=X.shape[0])
     D = np.concatenate((X, y.reshape(-1,1)), 1)
     
     return D       
 
+def sample_f_values(f_range: List, N: int=1) -> np.array:
+    '''
+    Sample function values from a given range.
+    
+            Parameters:
+                    f_range (List): range of function values.
+                    N (int): sample size.
+                    
+            Returns:
+                    Sample of size N from uniform distribution defined by f_range.
+                    
+    '''
+    
+    return uniform(f_range[0],f_range[1]-f_range[0]).rvs(N)
+
 def omega_hypothesis_sampler(hypothesis: rv_continuous, J: int, i: int, **kwargs):
     
     while True:
@@ -166,3 +172,143 @@ def omega_sampler(f: Optional[PWL], hypothesis: rv_continuous, num_tries: int=10
             omega_samples.append(sample)
             
     return np.atleast_2d(omega_samples) if omega_samples is not None else omega_samples
+
+def X_sampler(Ps: np.array, N: int, weights: list, **kwargs):
+    '''
+    Sample from a mixed Gaussian distribution restricted to a union of polytopes Ps. 
+    Samples will be in the convex hull of the union of Ps.
+    Sampling is done using the Hit & Run algorithm following the work of
+    Ben Cousins in Efficient High-dimensional Sampling and Integration.
+    
+            Parameters:
+                    Ps (np.array): Polytopes.
+                    N (int): Overall sample size.
+                    weights (list): Weight of each Gaussian in the mix [must add up to 1].
+                    num_cpus (int): Number of CPUs to parallelize sampling (default: 1).
+
+                    
+            Returns:
+                    N samples (np.array).
+                    
+    '''
+
+    means = kwargs['mean']
+    covariances = kwargs['cov']
+    
+    is_round = kwargs['is_round'] if 'is_round' in kwargs else True 
+    round_threshold = kwargs['round_threshold'] if 'round_threshold' in kwargs else 0.1
+    upper_bound = kwargs['upper_bound'] if 'upper_bound' in kwargs else np.inf 
+    lower_bound = kwargs['lower_bound'] if 'lower_bound' in kwargs else 1.0
+    T = kwargs['T'] if 'T' in kwargs else 1 
+    tol = kwargs['tol'] if 'tol' in kwargs else 1e-8
+    num_cpus = kwargs['num_cpus'] if 'num_cpus' in kwargs else 1 
+    
+    objective_id = kwargs['objective_id'] if 'objective_id' in kwargs else ''
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    
+    assert abs(sum(weights)-1)<tol, 'Weights must add up to 1.'
+
+    lens = [len(means),len(covariances),len(weights)]    
+    assert min(lens) == max(lens), 'Unequal number of policies, covariances, and weights.'    
+
+    Ns = [int(w*N) for w in weights]
+    Ns[-1] += N-sum(Ns)
+
+    points = np.unique(np.vstack(Ps),axis=0)
+    hull, _, _ = get_hull(points)
+    d = points.shape[-1]
+    
+    Xs = []
+    
+    sample_slice = kwargs['sample_slice'] if 'sample_slice' in kwargs else slice(0,len(Ns))
+
+    if logger_name:
+        log = logging.getLogger(logger_name)
+        log.info(f'Sampling {N} data points for objective {objective_id} (mix time T={T}) with {num_cpus} cpus.')
+        log.info(f'rounding={is_round}, rounding threshold={round_threshold:.3f}, sigma upper_bound={upper_bound:.3f}, sigma lower_bound={lower_bound:.3f}.')
+
+    for n, mean, covariance in zip(Ns[sample_slice], means[sample_slice], covariances[sample_slice]):
+
+        u, s, uT = la.svd(covariance,full_matrices=False)
+        B = np.diag(s**(0.5)) @ uT # square root of covariance
+        Binv = u @ np.diag(s**(-0.5))
+        
+        assert np.all(np.isclose(B@Binv, np.eye(d), atol=tol)), 'Root of covariance and its inverse multiply to I.'
+        assert np.all(np.isclose(covariance, (u @ np.diag(s**(0.5))) @ (np.diag(s**(0.5)) @ uT), atol=tol)), 'Retrieve original covariance from SVD decomposition.'
+
+        points_init = points @ B
+        mean_init = mean @ B
+        hull_init, _, simplices_init = get_hull(points_init)
+        shift_init = mean_init
+        scale_init = scale(mean_init, simplices_init[:,0,:], hull_init.equations[:,:-1])
+
+        # shift & scale for unit ball around mean inside polytope
+        points_tmp = (points_init-shift_init)/scale_init
+        mean_tmp = (mean_init-shift_init)/scale_init
+
+        # round polytope. no rounding iff A = I.
+        if is_round:
+            points_tmp, A = rounding(points_tmp,round_threshold,tol=tol)
+        else:
+            A = np.eye(d)
+        Ainv = la.inv(A)
+        Avals = la.eigvals(A)
+        
+        mean_tmp = (A@mean_tmp.T).T
+        hull_tmp, _, simplices_tmp = get_hull(points_tmp)
+
+        # shift & scale for unit ball around mean inside rounded polytope
+        shift_tmp = mean_tmp
+        scale_tmp = scale(mean_tmp, simplices_tmp[:,0,:], hull_tmp.equations[:,:-1])
+        points_tmp = (points_tmp-shift_tmp)/scale_tmp
+        mean_tmp = (mean_tmp-shift_tmp)/scale_tmp
+
+        hull_tmp, _, _ = get_hull(points_tmp)
+
+        # when A = I, sigma_sq is scaled to produce samples from cov.
+        # when A != I, produced samples are not from cov, but from A @ cov @ A^T.
+        # then, sigma_sq is additionally scaled by A evals.
+        sigma = max(min(upper_bound,1/scale_init * gmean(Avals) * 1/scale_tmp),lower_bound)
+        sigma_sq = sigma**2
+
+        # sigma for warm start
+        warm_sigma = kwargs['warm_sigma'] if 'warm_sigma' in kwargs else 0.1*sigma
+        warm_sigma_sq = warm_sigma**2
+
+        if logger_name:
+            log = logging.getLogger(logger_name)
+            log.info(f'Producing {n} samples at policy {mean} and sigma {sigma:.3f}.')
+
+        # add epsilon to ensure sampled points are well inside 
+        hull_tmp_equations_eps = hull_tmp.equations+np.hstack([np.zeros((hull_tmp.equations.shape[0],hull_tmp.equations.shape[-1]-1)),
+                                                                        tol * np.ones(hull_tmp.equations.shape[0])[:,None]])
+            
+        X = hit_and_run(n,mean_tmp,hull_tmp_equations_eps,T,warm_sigma_sq,sigma_sq=sigma_sq,num_cpus=num_cpus,tol=tol)
+
+        # reverse apply transformations
+        X = scale_tmp*X+shift_tmp
+        X = X@Ainv
+        X = scale_init*X+shift_init
+        X = X@Binv
+
+        Xs.append(X)
+    
+    X = np.vstack(Xs)
+    np.random.shuffle(X)
+    
+    assert np.all(in_domain(X, hull.equations, tol=tol)), f'SANITY: samples not inside polytope for objective {objective_id}!'
+    
+    if len(Ns[sample_slice])==len(Ns):
+        assert np.unique(X,axis=1).shape[0]==N, f'SANITY: {np.unique(X,axis=1).shape[0]} unique samples generated, but required {N} samples.'
+    
+    return X
+
+def D_sampler(f: PWL, N: int, weights: list, noise: float, **kwargs): 
+        
+    domain_scale = np.power(f.volume(),1/f.dim)
+    
+    X = X_sampler(f.Ps,N,weights,upper_bound=1.2*domain_scale,lower_bound=0.1*domain_scale,**kwargs)
+    y = f.evaluate(X) + norm(loc=0,scale=noise).rvs(size=X.shape[0])
+    D = np.concatenate((X, y.reshape(-1,1)), 1)
+    
+    return D       
\ No newline at end of file
diff --git a/doframework/flow/datasets.py b/doframework/flow/datasets.py
index f5a0518..bf64221 100644
--- a/doframework/flow/datasets.py
+++ b/doframework/flow/datasets.py
@@ -23,6 +23,7 @@
 import yaml
 import json
 from datetime import datetime
+from typing import Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -30,15 +31,18 @@
 
 from doframework.core.inputs import generate_id, setup_logger
 from doframework.core.pwl import PWL
-from doframework.core.sampler import D_sampler
+from doframework.core.sampler import D_sampler, D_sampler_legacy
 
-def generate_dataset(obj_input: dict, obj_name: str, **kwargs):
+def generate_dataset(obj_input: dict, obj_name: str, **kwargs) -> Tuple[pd.DataFrame, str]:
     
     input_prefix = 'objective'
     input_suffix = 'json'
     output_prefix = 'data'
     output_suffix = 'csv'
 
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    num_cpus = kwargs['num_cpus'] if 'num_cpus' in kwargs else 1
+
     objective_id = re.match(input_prefix+'_'+'(\w+)'+'.'+input_suffix,obj_name).group(1)
     assert objective_id == obj_input['objective_id'], 'Mismatch between file name recorded in json and file name.'
 
@@ -56,17 +60,22 @@ def generate_dataset(obj_input: dict, obj_name: str, **kwargs):
     data_hypothesis = obj_input['data']['hypothesis']
     data_hypothesis_obj = getattr(scipy.stats,data_hypothesis)
 
-    D = D_sampler(f, data_hypothesis_obj, N, weights, noise, mean=policies, cov=covariances)
-    
+    # D = D_sampler_legacy(f, data_hypothesis_obj, N, weights, noise, mean=policies, cov=covariances)
+    D = D_sampler(f, N, weights, noise, mean=policies, cov=covariances, objective_id=objective_id, logger_name=logger_name, num_cpus=num_cpus)
+
+    if logger_name:
+        log = logging.getLogger(logger_name)
+        log.info('Sampling dataset {} for objective {} resulted in {} NaN values.'.format(data_id,objective_id,D[np.isnan(D).any(axis=1)].shape[0]))
+
     df = pd.DataFrame(D,columns=[f'x{i}' for i in range(D.shape[1]-1)]+['y'])
     generated_file = ''.join(['_'.join([output_prefix,objective_id,data_id]),'.',output_suffix])
 
-    #### NOTE: add file name till rayvens allows to read file name from source bucket event
-    # df = pd.concat([df,pd.DataFrame([generated_file]*df.shape[0],columns=['generated_file_name'])],axis=1) 
-    
     return df, generated_file
 
-def main(data_root: str, args: dict, logger_name: str=None, is_raised=True):
+def main(data_root: str, args: argparse.Namespace, **kwargs):
+
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    is_raised = args.is_raised
 
     for p in Path(os.path.join(data_root,'objectives')).rglob('*.json'):
         
@@ -77,18 +86,18 @@ def main(data_root: str, args: dict, logger_name: str=None, is_raised=True):
                 obj_name = p.name
                 if logger_name:
                     log = logging.getLogger(logger_name)
-                    log.info('Loaded {}.'.format(file.name))        
+                    log.info('Loaded objective {}.'.format(obj_name))
                 
             obj_id = obj_name # obj_input['objective_id']
             
             if logger_name:
                 log = logging.getLogger(logger_name)
-                log.info('Sampling {} datasets for {}.'.format(args.datasets,obj_id))        
+                log.info('Sampling {} datasets for {} with {} CPUs.'.format(args.datasets,obj_id,args.cpus))        
                 
             for i in range(args.datasets):
                 
-                df, gen_data_file = generate_dataset(obj_input,obj_name)                
-                gen_data_path = os.path.join(data_root,'data',gen_data_file)                
+                df, gen_data_file = generate_dataset(obj_input,obj_name,logger_name=logger_name,is_raised=is_raised,num_cpus=args.cpus)              
+                gen_data_path = os.path.join(data_root,'data-dest',gen_data_file)
                 df.to_csv(gen_data_path,index=False)
                 
         except IOError as e:
@@ -103,6 +112,11 @@ def main(data_root: str, args: dict, logger_name: str=None, is_raised=True):
                 log.error('Error occured while decoding obective json.\n')
                 log.error(e)
             if is_raised: raise e
+        except AssertionError as e:
+            if logger_name:
+                log = logging.getLogger(logger_name)
+                log.error(e)
+            if is_raised: raise e
         except Exception as e:
             if logger_name:
                 log = logging.getLogger(logger_name)
@@ -113,14 +127,16 @@ def main(data_root: str, args: dict, logger_name: str=None, is_raised=True):
 if __name__ == '__main__':
     
     parser = argparse.ArgumentParser()
-    parser.add_argument("-s", "--datasets", type=int, default=1, help="Number of datasets to generate.")
+    parser.add_argument("-c", "--configs", type=str, help="Specify the absolute path of the configs file.")
+    parser.add_argument("-s", "--datasets", type=int, default=1, help="Number of datasets to generate (default: 1).")
     parser.add_argument("-l", "--logger", action="store_true", help="Enable logging.")
+    parser.add_argument("-r", "--is_raised", action="store_true", help="Raise assertions and terminate run.")
+    parser.add_argument("--cpus", type=int, default=1, help="Number of CPUs to sample data (default: 1).")
     args = parser.parse_args()
 
-    configs_path = os.environ['HOME']
-    configs_file = 'configs.yaml'
+    configs_path = args.configs
 
-    with open(os.path.join(configs_path,configs_file),'r') as file:
+    with open(configs_path,'r') as file:
         try:
             configs = yaml.safe_load(file)
         except yaml.YAMLError as e:
@@ -142,4 +158,4 @@ def main(data_root: str, args: dict, logger_name: str=None, is_raised=True):
         log.info('Running on user %s', user)
         log.info('Data root %s', data_root)
 
-    main(data_root, args, logger_name)
\ No newline at end of file
+    main(data_root, args, logger_name=logger_name)
\ No newline at end of file
diff --git a/doframework/flow/metrics.py b/doframework/flow/metrics.py
index 77405eb..036c996 100644
--- a/doframework/flow/metrics.py
+++ b/doframework/flow/metrics.py
@@ -51,12 +51,15 @@ def files_from_solution(solution_name: str) -> dict:
 
     return {'objective': f'objective_{objective_id}.json', 'data': f'data_{objective_id}_{data_id}.csv'}
 
-def generate_metric(solution_input: dict, solution_name: str, is_mcmc: bool=False, logger_name: Optional[str]=None, is_raised: Optional[bool]=False, **kwargs) -> Tuple[Optional[dict], Optional[str]]:    
+def generate_metric(solution_input: dict, solution_name: str, is_mcmc: bool=False, **kwargs) -> Tuple[Optional[dict], Optional[str]]:    
 
     output_prefix = 'metrics'
     output_suffix = 'json'
     extra_input = ['objective','data']
 
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    is_raised = kwargs['is_raised'] if 'is_raised' in kwargs else False
+
     if all([k in kwargs for k in extra_input]) and all([v is not None for k,v in kwargs.items() if k in extra_input]):
 
         objective_id, data_id, solution_id = _ids_from_solution(solution_name)
@@ -122,7 +125,11 @@ def generate_metric(solution_input: dict, solution_name: str, is_mcmc: bool=Fals
 
         return None, None
 
-def main(data_root: str, is_mcmc: bool=False, logger_name: str=None, is_raised=True):
+def main(data_root: str, args: argparse.Namespace, **kwargs):
+
+    is_mcmc = args.mcmc
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    is_raised = args.is_raised
 
     for p in Path(os.path.join(data_root,'solutions')).rglob('*.json'):
         
@@ -191,14 +198,15 @@ def main(data_root: str, is_mcmc: bool=False, logger_name: str=None, is_raised=T
 if __name__ == '__main__':
         
     parser = argparse.ArgumentParser()
+    parser.add_argument("-c", "--configs", type=str, help="Specify the absolute path of the configs file.")
     parser.add_argument("-mc", "--mcmc", action="store_true", help="Optimize GP kernel hyperparameters with MCMC [otherwise, maximum likelihood].")
     parser.add_argument("-l", "--logger", action="store_true", help="Enable logging.")
+    parser.add_argument("-r", "--is_raised", action="store_true", help="Raise assertions and terminate run.")
     args = parser.parse_args()
 
-    configs_path = os.environ['HOME']
-    configs_file = 'configs.yaml'
+    configs_path = args.configs
 
-    with open(os.path.join(configs_path,configs_file),'r') as file:
+    with open(configs_path,'r') as file:
         try:
             configs = yaml.safe_load(file)
         except yaml.YAMLError as e:
@@ -220,4 +228,4 @@ def main(data_root: str, is_mcmc: bool=False, logger_name: str=None, is_raised=T
         log.info('Running on user %s', user)
         log.info('Data root %s', data_root)
 
-    main(data_root, args.mcmc, logger_name)
\ No newline at end of file
+    main(data_root, args, logger_name=logger_name)
\ No newline at end of file
diff --git a/doframework/flow/mock.py b/doframework/flow/mock.py
index 97c321e..6540df4 100644
--- a/doframework/flow/mock.py
+++ b/doframework/flow/mock.py
@@ -71,7 +71,7 @@ def generate_objective_mock(meta_input: dict, meta_name: str, **kwargs) -> Tuple
 
 def generate_dataset_mock(obj_input: dict, obj_name: str, **kwargs) -> Tuple[Optional[pd.DataFrame], Optional[str]]:
     '''
-    generate_dataset test for end-to-end integration.
+    generate_dataset test for end-to-end integration. The mock dataset will be sampled for the function (x**2 + y**2)*np.sin(np.pi*x*y/16).
     
             Parameters:
                     obj_input (dict): Objective target dictionary. 
@@ -144,7 +144,8 @@ def generate_dataset_mock(obj_input: dict, obj_name: str, **kwargs) -> Tuple[Opt
 
 def generate_solution_mock(predict_optimize, data_input: pd.DataFrame, data_name: str, **kwargs) -> Tuple[Optional[dict], Optional[str]]:
     '''
-    generate_solution test for end-to-end integration.
+    generate_solution test for end-to-end integration. The solutions will be generated for the test function (x**2 + y**2)*np.sin(np.pi*x*y/16).
+    The optimization will be constrained to -2 =< x,y <= 2. The solutions produced will be on the vertices [+-2, +-2].
     
             Parameters:
                     predict_optimize: Predit-then-optimize algorithm.
diff --git a/doframework/flow/objectives.py b/doframework/flow/objectives.py
index 1707ac3..6dfdfef 100644
--- a/doframework/flow/objectives.py
+++ b/doframework/flow/objectives.py
@@ -43,7 +43,7 @@ def calculate_objectives(meta_input: dict, args: dict) -> int:
     return objectives
 
 #### TODO: remove the dependence on poly to improve performance
-def get_omega_P(vertex_input: dict, poly, logger_name: Optional[str]=None,is_raised: Optional[bool]=False) -> np.array:
+def get_omega_P(vertex_input: dict, poly, logger_name: Optional[str]=None, is_raised: bool=False) -> np.array:
 
     if 'position' in vertex_input:
         points = np.atleast_2d(np.array(vertex_input['position']))
@@ -79,7 +79,7 @@ def get_omega_P(vertex_input: dict, poly, logger_name: Optional[str]=None,is_rai
             log.error('QHull failure on points: {}.'.format([list(row) for row in points]))
         if is_raised: raise e
         
-def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[str]=None, is_raised: Optional[bool]=False, **kwargs) -> Tuple[dict, str]:
+def generate_objective(meta_input: dict, meta_name: str, **kwargs) -> Tuple[dict, str]:
     '''
     Generate PWL objective targets from meta input.
     
@@ -96,6 +96,9 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
     output_prefix = 'objective'
     output_suffix = 'json'
 
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    is_raised = kwargs['is_raised'] if 'is_raised' in kwargs else False
+
     objective_id = generate_id()
 
     f = meta_input['f']
@@ -116,7 +119,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
     if 'position' in f['vertices']:
         
         f_points = np.atleast_2d(np.array(f['vertices']['position']))
-        f_supp_range = np.array([[f_points[:,i].min(),f_points[:,i].max()] for i in range(dim)])
+        f_domain_range = np.array([[f_points[:,i].min(),f_points[:,i].max()] for i in range(dim)])
         f_hull = ConvexHull(f_points,qhull_options='QJ')
         f_P = f_hull.points[f_hull.vertices,:]
         if logger_name:
@@ -126,7 +129,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
         f_Ps = [f_P]
             
         omega_vertices = omega['vertices'] # in this case, omega must have 'vertices', which must have either 'position' or 'num'
-        omega_P = get_omega_P(omega_vertices,f_poly,logger_name,is_raised)
+        omega_P = get_omega_P(omega_vertices,f_poly,logger_name=logger_name,is_raised=is_raised)
         omega_Ps = [omega_P]
         
         if 'coeffs' in f['values']:
@@ -139,7 +142,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
         else:
             if logger_name:
                 log = logging.getLogger(logger_name)
-                log.info('Sampling {} values for Supp(f) vertices.'.format(f_P.shape[0]))
+                log.info('Sampling {} values for Dom(f) vertices.'.format(f_P.shape[0]))
             f_V = sample_f_values(f['values']['range'],f_P.shape[0])
             omega_V = PolyLinear(f_P,f_V).evaluate(omega_P) 
         
@@ -148,7 +151,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
                 
     else:
 
-        f_supp_range = np.atleast_2d(np.array(f['vertices']['range']))
+        f_domain_range = np.atleast_2d(np.array(f['vertices']['range']))
         f_P = np.vstack(list(map(np.array, it.product(*f['vertices']['range']))))        
         
         if 'coeffs' in f['values']:
@@ -156,7 +159,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
             f_poly = Polyhedron(f_P) #### TODO: remove the dependence on f_poly to improve performance
             f_Ps = [f_P]    
             omega_vertices = omega['vertices'] # omega must have vertices in this case
-            omega_P = get_omega_P(omega_vertices,f_poly,logger_name=logger_name,is_raised=is_raised)        
+            omega_P = get_omega_P(omega_vertices,f_poly,logger_name=logger_name,is_raised=is_raised)     
             omega_Ps = [omega_P]
             f_coeffs = f['values']['coeffs']
             f_V = np.pad(f_P,[(0,0),(0,1)],constant_values=1) @ f_coeffs
@@ -183,7 +186,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
             p_process = Process(uniform(scale=p))
             q_process = Process(uniform(scale=q))
 
-            f_supp, omega_supp = triangulation(f_supp_range, f_range, ratio, vertex_num, dim, p_process, q_process, regularization_min_prob, logger_name=logger_name, is_raised=is_raised)            
+            f_supp, omega_supp = triangulation(f_domain_range, f_range, ratio, vertex_num, dim, p_process, q_process, regularization_min_prob, logger_name=logger_name, is_raised=is_raised)            
             f_Ps = flatten([[leaf.poly.points for leaf in tree.leaves()] for tree in flatten(f_supp)])
             f_Vs = flatten([[leaf.poly.values for leaf in tree.leaves()] for tree in flatten(f_supp)])
             omega_Ps = flatten([[leaf.poly.points for leaf in tree.leaves()] for tree in flatten(omega_supp)])
@@ -193,11 +196,12 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
     output['f']['values'] = [list(V) for V in f_Vs]
 
     pwl = PWL(f_Ps,f_Vs)
-    f_supp_scale = np.power(pwl.volume(),1/dim) # width parameter, approx of f domain diameter 
+    domain_scale = np.power(pwl.volume(),1/dim) # domain "radius" parameter
+    omega_scale = omega['scale'] if 'scale' in omega else 0.0
 
     omega_hull = ConvexHull(np.vstack(omega_Ps))
-    omega_locs = omega_hull.points[omega_hull.vertices,:] # this may shift original vertices on the order of 1e-8
-    omega_scales = np.random.rand(*omega_locs.shape)*omega['scale']*f_supp_scale
+    omega_locs = omega_hull.points[omega_hull.vertices,:] # may shift original vertices by order of 1e-8
+    omega_scales = np.random.rand(*omega_locs.shape)*omega_scale*domain_scale
 
     output['omega']['polyhedrons'] = [[list(point) for point in P] for P in omega_Ps]
     output['omega']['hypothesis'] = omega['hypothesis'] if 'hypothesis' in omega else 'norm'
@@ -207,7 +211,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
     policies = pwl.sample(data['policy_num'])
     eigenvals = np.vstack([sample_standard_simplex(dim)*dim for _ in range(data['policy_num'])])
     corrs = [random_correlation.rvs(e) for e in eigenvals]
-    sigmas = [np.random.rand(dim)*data['scale']*f_supp_scale for _ in range(data['policy_num'])]
+    sigmas = [np.random.rand(dim)*data['scale']*domain_scale for _ in range(data['policy_num'])]
     covs = [np.diag(sigma) @ corr @ np.diag(sigma) for corr, sigma in zip(corrs,sigmas)]
     weights = sample_standard_simplex(data['policy_num'])
 
@@ -217,6 +221,7 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
     output['data']['covariances'] = [[list(row) for row in cov] for cov in covs]
     output['data']['weights'] = list(weights)
     output['data']['noise'] = data['noise']*(np.array(f_Vs).max()-np.array(f_Vs).min())
+    output['data']['scale'] = data['scale']
 
     opt_fns = {'min': np.nanargmin, 'max': np.nanargmax}
     for opt in ['min','max']:    
@@ -236,12 +241,15 @@ def generate_objective(meta_input: dict, meta_name: str, logger_name: Optional[s
 
     return output, generated_file
 
-def main(data_root: str, args: dict, logger_name: Optional[str]=None,is_raised: Optional[bool]=True):
+def main(data_root: str, args: argparse.Namespace, **kwargs):
 
     with open(os.path.join(data_root,'inputs',args.input_file),'r') as file:
         meta_input = json.load(file)
         meta_name = args.input_file
 
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    is_raised = args.is_raised
+
     legit_input(meta_input,logger_name=logger_name,is_raised=is_raised)
 
     n = calculate_objectives(meta_input,args)
@@ -255,7 +263,7 @@ def main(data_root: str, args: dict, logger_name: Optional[str]=None,is_raised:
         try:
 
             obj_output, obj_file = generate_objective(meta_input,meta_name,logger_name=logger_name,is_raised=is_raised)
-            obj_path = os.path.join(data_root,'objectives',obj_file)
+            obj_path = os.path.join(data_root,'objectives-dest',obj_file)
 
             with open(obj_path,'w') as file:
                 json.dump(obj_output, file)
@@ -266,6 +274,11 @@ def main(data_root: str, args: dict, logger_name: Optional[str]=None,is_raised:
                 log.error('Failed to dump generated objective into json.\n')
                 log.error(e)
             if is_raised: raise e
+        except AssertionError as e:
+            if logger_name:
+                log = logging.getLogger(logger_name)
+                log.error(e)
+            if is_raised: raise e
         except Exception as e:
             if logger_name:
                 log = logging.getLogger(logger_name)
@@ -277,14 +290,15 @@ def main(data_root: str, args: dict, logger_name: Optional[str]=None,is_raised:
     
     parser = argparse.ArgumentParser()
     parser.add_argument("input_file", type=str, help="Specify name of input json file from data inputs dir.")
+    parser.add_argument("-c", "--configs", type=str, help="Specify the absolute path of the configs file.")
     parser.add_argument("-o", "--objectives", type=int, default=1, help="Number of simulation objectives to produce.")
     parser.add_argument("-l", "--logger", action="store_true", help="Enable logging.")
+    parser.add_argument("-r", "--is_raised", type=bool, default=False, help="Raise assertions and terminate run.")
     args = parser.parse_args()
 
-    configs_path = os.environ['HOME']
-    configs_file = 'configs.yaml'
+    configs_path = args.configs
 
-    with open(os.path.join(configs_path,configs_file),'r') as file:
+    with open(configs_path,'r') as file:
         try:
             configs = yaml.safe_load(file)
         except yaml.YAMLError as e:
@@ -294,17 +308,18 @@ def main(data_root: str, args: dict, logger_name: Optional[str]=None,is_raised:
 
     user = getpass.getuser()
     data_root = configs[user]['data']
+    
 
     now = datetime.now().strftime('%Y-%m-%d_%H%M')
     log_file = 'generanted_objective_{}.log'.format(now)
     log_path = os.path.join(data_root,'logs',log_file)
     logger_name = 'generanted_objective_log' if args.logger else None
     setup_logger(logger_name, log_path)
-
+    
     if logger_name:                
         log = logging.getLogger(logger_name)                
         log.info('Running on user %s', user)
         log.info('Data root %s', data_root)
         log.info('Parsing input file %s', args.input_file)
 
-    main(data_root, args, logger_name)
\ No newline at end of file
+    main(data_root, args, logger_name=logger_name)
\ No newline at end of file
diff --git a/doframework/flow/solutions.py b/doframework/flow/solutions.py
index fb491b9..dba896f 100644
--- a/doframework/flow/solutions.py
+++ b/doframework/flow/solutions.py
@@ -60,6 +60,7 @@ def generate_solution(predict_optimize, data_input: pd.DataFrame, data_name: str
     extra_input = ['objective']
 
     logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    epsilon = kwargs['epsilon'] if 'epsilon' in kwargs else 1e-6
 
     if 'is_minimum' in kwargs:    
         is_minimum = kwargs['is_minimum']
@@ -106,10 +107,14 @@ def generate_solution(predict_optimize, data_input: pd.DataFrame, data_name: str
 
         output['omega'] = {}
         output['omega']['vertices'] = [list(v) for v in omega_approx_hull_vertices]
-        constraints = np.unique(omega_approx_hull.equations,axis=0)
+        constraints = np.unique(omega_approx_hull.equations,axis=0) # shifts vertices by 1e-7 to 1e-8 error
         output['omega']['constraints'] = [list(c) for c in constraints]
 
-        arg, val, model = predict_optimize(D, constraints, **extra)
+        # add epsilon to ensure solution inside dom(f) (dependent on optimizer feasibility sensitivity)
+        constraints_eps = constraints+np.hstack([np.zeros((constraints.shape[0],constraints.shape[1]-1)),epsilon*np.ones(constraints.shape[0])[:,None]])
+
+        # remove rows with nan values in data
+        arg, val, model = predict_optimize(D[~np.isnan(D).any(axis=1)], constraints_eps, **extra)
         solution = optimalSolution(arg, val)
 
         if logger_name:
@@ -159,7 +164,10 @@ def generate_solution(predict_optimize, data_input: pd.DataFrame, data_name: str
 
         return None, None
 
-def main(data_root: str, args, logger_name: str=None, is_raised=False):
+def main(data_root: str, args: argparse.Namespace, **kwargs):
+
+    logger_name = kwargs['logger_name'] if 'logger_name' in kwargs else None
+    is_raised = args.is_raised
 
     from doframework.core.optimizer import predict_optimize # test with built-in model
 
@@ -189,7 +197,7 @@ def main(data_root: str, args, logger_name: str=None, is_raised=False):
                 opt_output, opt_file = generate_solution(predict_optimize, data_input, data_name, logger_name=logger_name, is_raised=is_raised, objective=objective)
                 
                 if (opt_output is not None) and (opt_file is not None):
-                    opt_path = os.path.join(data_root,'solutions',opt_file)
+                    opt_path = os.path.join(data_root,'solutions-dest',opt_file)
                     with open(opt_path,'w') as file:
                         json.dump(opt_output, file)                        
 
@@ -225,14 +233,15 @@ def main(data_root: str, args, logger_name: str=None, is_raised=False):
 if __name__ == '__main__':
     
     parser = argparse.ArgumentParser()
+    parser.add_argument("-c", "--configs", type=str, help="Specify the absolute path of the configs file.")
     parser.add_argument("-r", "--regions", type=int, default=1, help="Number of feasibility regions [i.e., omegas] to generate per dataset [default: 1].")
     parser.add_argument("-l", "--logger", action="store_true", help="Enable logging.")
+    parser.add_argument("-r", "--is_raised", action="store_true", help="Raise assertions and terminate run.")
     args = parser.parse_args()
 
-    configs_path = os.environ['HOME']
-    configs_file = 'configs.yaml'
+    configs_path = args.configs
 
-    with open(os.path.join(configs_path,configs_file),'r') as file:
+    with open(configs_path,'r') as file:
         try:
             configs = yaml.safe_load(file)
         except yaml.YAMLError as e:
@@ -254,4 +263,4 @@ def main(data_root: str, args, logger_name: str=None, is_raised=False):
         log.info('Running on user %s', user)
         log.info('Data root %s', data_root)
 
-    main(data_root, args, logger_name)
\ No newline at end of file
+    main(data_root, args, logger_name=logger_name)
\ No newline at end of file
diff --git a/examples/doframework_example.py b/examples/doframework_example.py
index 796e4cb..ce8b61a 100644
--- a/examples/doframework_example.py
+++ b/examples/doframework_example.py
@@ -29,4 +29,4 @@ def predict_optimize_resolved(data: np.array, constraints: np.array, **kwargs):
     parser.add_argument("-c", "--configs", type=str, help="User configs.yaml.")
     args = parser.parse_args()
     
-    dof.run(predict_optimize_resolved, args.configs, objectives=2, datasets=2)
+    dof.run(predict_optimize_resolved, args.configs, objectives=3, datasets=3, data_num_cpus=2)
diff --git a/notebooks/sampling.ipynb b/notebooks/sampling.ipynb
new file mode 100644
index 0000000..a1f99f0
--- /dev/null
+++ b/notebooks/sampling.ipynb
@@ -0,0 +1,732 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d4764c32",
+   "metadata": {},
+   "source": [
+    "# Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6b138044",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from time import perf_counter, gmtime, strftime"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "eb7be00f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import numpy.linalg as la"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "26e548c7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from doframework.core.hit_and_run import hit_and_run_square_test, hit_and_run\n",
+    "from doframework.core.hit_and_run import get_hull, scale, box_sample, plot_polytope, rounding, in_domain\n",
+    "from doframework.core.hit_and_run import warm_start as sample_by_exclusion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f20dffb4",
+   "metadata": {},
+   "source": [
+    "# Global parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "98aa28af",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tol = 1e-8\n",
+    "num_cpus = 4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "84b32b8a",
+   "metadata": {},
+   "source": [
+    "# Hit & Run\n",
+    "\n",
+    "This notebook demonstrates the use of the Hit & Run algorithm to sample points from a Gaussian restricted to a polytope. The Hit & Run algorithm is good for convex bodies more generally.\n",
+    "\n",
+    "Our implementation follows the work of **Ben Cousins** in *Efficient High-dimensional Sampling and Integration* (PhD Thesis, 2017)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9307e46",
+   "metadata": {},
+   "source": [
+    "### Hyper-Parameters\n",
+    "\n",
+    "* ```sigma_sq```: the variance of the spherical Gaussian to be sampled.\n",
+    "* ```delta```: the variance of the spherical Gaussian that serves as a warm start for Hit & Run.\n",
+    "* ```N```: the number of samples to sample.\n",
+    "* ```T```: the mixing time for the Hit & Run walk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "65ebd9fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigma_sq = 1.0\n",
+    "delta = 0.1\n",
+    "N = 2000\n",
+    "T = 20"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9b654f71",
+   "metadata": {},
+   "source": [
+    "### Test\n",
+    "\n",
+    "First, let's run a test for the Hit & Run algorithm. We will sample a small spherical Gaussian inside a large square. We expect to sample from a multivariate normal distribution -- restriction to the large square should not have an effect. Our sample should pass a normality test (we will use Henze-Zirkler).\n",
+    "\n",
+    "We will project the Hit & Run samples on one of the coordinates and see how it compares to the Gaussian with the sam variance.\n",
+    "\n",
+    "We will also one iteration of Hit & Run. In a nutshell, a chord is established in a randon direction through the current point. Then, a point is sampled from the $1$-dimensional Gaussian projected onto this chord. The point is rejected if it outside the polytope. And so on it goes."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9fdd6f71",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Henze-Zirkler multivariate normality sample test: True\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x1008 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hit_and_run_square_test(N=N, T=T, sigma_sq=sigma_sq, delta=delta, num_cpus=num_cpus, tol=tol, figsize=(7,14))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0562401e",
+   "metadata": {},
+   "source": [
+    "### 2D Polytope\n",
+    "\n",
+    "We will use the Hit & Run algorithm to sample *uniformally* from some ranodm $2$-dimensional polytopes.\n",
+    "\n",
+    "The random polytope will be sampled as the convex hull of $P$ ransom points in a box $B$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "86e96663",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "box_lows = [-1,-1]\n",
+    "box_highs = [1,1]\n",
+    "\n",
+    "assert len(box_lows)==len(box_highs), 'Box dimension mismatch.'\n",
+    "\n",
+    "d = len(box_lows)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e3646a01",
+   "metadata": {},
+   "source": [
+    "Number $N$ of sampled points to generate the polytope."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d7a5dcc4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "P = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "738a1ef0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "points = box_sample(box_lows,box_highs,d,P)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "cca8263b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hull, vertices, simplices = get_hull(points)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0df9a99c",
+   "metadata": {},
+   "source": [
+    "The algorithm assumes there's a unit ball inside the polytope. Hence, we'll shift relative to the center of mass and scale. \n",
+    "\n",
+    "Note that Hit & Run assumes we have one point inside the convex body to begin with. This is easy with a polytope."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "194345e6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm = np.average(vertices,axis=0)[None,:]\n",
+    "ratio = scale(cm, simplices[:,0,:], hull.equations[:,:-1])\n",
+    "\n",
+    "points = (points-cm)/ratio \n",
+    "hull, vertices, simplices = get_hull(points)\n",
+    "origin = np.average(vertices,axis=0)[None,:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "347995c5",
+   "metadata": {},
+   "source": [
+    "We'll now run the algorithm. Note that we do not provide the variance. The algorithm will sample uniformally by default.\n",
+    "\n",
+    "We provide ```num_cpus``` to parallelize the sampling process across various workers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "9543f6b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = hit_and_run(N,origin,hull.equations,T,delta,num_cpus=num_cpus,tol=tol)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9d889c17",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_polytope(hull, X=X)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7149ef28",
+   "metadata": {},
+   "source": [
+    "## 3D\n",
+    "\n",
+    "We will use the Hit & Run algorithm to sample a spherical Gaussian restricted to some ranodm $3$-dimensional polytopes.\n",
+    "\n",
+    "Again, the random polytope will be sampled as the convex hull of $P$ ransom points in a box $B$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "952a52ab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "box_lows = [-1,-1,-1]\n",
+    "box_highs = [1,1,1]\n",
+    "\n",
+    "assert len(box_lows)==len(box_highs), 'Box dimensions mismatch.'\n",
+    "\n",
+    "d = len(box_lows)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "89e610a7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "P = 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "e12c7e0b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "points = box_sample(box_lows,box_highs,d,P)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "2caf04fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hull, vertices, simplices = get_hull(points)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a852f059",
+   "metadata": {},
+   "source": [
+    "Ensure a unit ball inside generated polytope around center of mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "df8a7327",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm = np.average(vertices,axis=0)[None,:]\n",
+    "ratio = scale(cm, simplices[:,0,:], hull.equations[:,:-1])\n",
+    "\n",
+    "points = (points-cm)/ratio \n",
+    "hull, vertices, simplices = get_hull(points)\n",
+    "origin = np.average(vertices,axis=0)[None,:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59b84e37",
+   "metadata": {},
+   "source": [
+    "Let's change the parameters a big."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "b0a02c61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigma_sq = 0.8\n",
+    "N = 1000\n",
+    "T = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "a74f8b2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = hit_and_run(N,origin,hull.equations,T,delta,sigma_sq=sigma_sq,num_cpus=num_cpus,tol=tol)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "21a8fe28",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_polytope(hull, origin, X)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fdf22daa",
+   "metadata": {},
+   "source": [
+    "### Exclusion"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f492c992",
+   "metadata": {},
+   "source": [
+    "Let's compare Hit & Run to sampling by exclusion. We'll use the same $3$-dimensional polytope above.\n",
+    "\n",
+    "Sampling by exclusion would be more or less unfeasible when the dimension $d>5$ (certainly on a local machine)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "c8631cd5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y = sample_by_exclusion(origin,hull.equations,sigma_sq,N)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "c6c0ce25",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 504x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_polytope(hull, origin, Y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "70709d99",
+   "metadata": {},
+   "source": [
+    "### High D\n",
+    "\n",
+    "We will now test the Hit & Run algorithm in higher dimensions. \n",
+    "\n",
+    "We need to be careful here. As we go up in dimension, the number of faces of a randomly sampled polytope baloons, the more points $P$ we have (up to some saturation level). Hit & Run performance is linear in the number of faces."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "7cd84365",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running in dimension: 12\n"
+     ]
+    }
+   ],
+   "source": [
+    "box_lows = [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]\n",
+    "box_highs = [1,1,1,1,1,1,1,1,1,1,1,1]\n",
+    "\n",
+    "assert len(box_lows)==len(box_highs), 'Box dimensions mismatch.'\n",
+    "\n",
+    "d = len(box_lows)\n",
+    "\n",
+    "print(f'Running in dimension: {d}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d26b9af3",
+   "metadata": {},
+   "source": [
+    "Sampling polytope as the convex hull of $P$ points inside the box $B$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "77f18588",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "P = 25"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "4e783fba",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "points = box_sample(box_lows,box_highs,d,P)\n",
+    "hull, vertices, simplices = get_hull(points)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2aabf36",
+   "metadata": {},
+   "source": [
+    "Ensure a unit ball inside generated polytope around center of mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "796f0afb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of faces of polytope: 16256\n"
+     ]
+    }
+   ],
+   "source": [
+    "cm1 = np.average(vertices,axis=0)[None,:]\n",
+    "ratio1 = scale(cm1, simplices[:,0,:], hull.equations[:,:-1])\n",
+    "\n",
+    "points = (points-cm1)/ratio1\n",
+    "hull, vertices, simplices = get_hull(points)\n",
+    "origin = np.average(vertices,axis=0)[None,:]\n",
+    "print('Number of faces of polytope:',simplices.shape[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c8b0468",
+   "metadata": {},
+   "source": [
+    "We perform a rounding step to facilitate sampling in higher dimensions. Rounding will make it less likely that Hit & Run will run into sharp conrners.\n",
+    "\n",
+    "Rounding is a linear transformation which we can later reverse apply to get a Gaussian sample of the original polytope (though not necessarily spherical)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "234fa237",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "points, A = rounding(points, tol=tol)\n",
+    "hull, vertices, simplices = get_hull(points)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56b10176",
+   "metadata": {},
+   "source": [
+    "We'll shift to the origin and scale to ensure unit ball inside again."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "2fb4a625",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cm2 = np.average(vertices,axis=0)[None,:]\n",
+    "ratio2 = scale(cm2, simplices[:,0,:], hull.equations[:,:-1])\n",
+    "\n",
+    "points = (points-cm2)/ratio2\n",
+    "hull, vertices, simplices = get_hull(points)\n",
+    "origin = np.average(vertices,axis=0)[None,:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "246d4035",
+   "metadata": {},
+   "source": [
+    "Here are the Hit & Run parameters again."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "bcdcc69c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sigma_sq = 1.1\n",
+    "delta = 0.2\n",
+    "N = 1000\n",
+    "T = 20"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "01769628",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t1 = perf_counter()\n",
+    "X = hit_and_run(N,origin,hull.equations,T,delta,sigma_sq=sigma_sq,num_cpus=num_cpus,tol=tol)\n",
+    "t2 = perf_counter()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "852f6e30",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hit & Run Convex Polytope Sampling:\n",
+      "Dimension: 12\n",
+      "N: 1000\n",
+      "H&R Tries: 20000\n",
+      "Variance: 1.1\n",
+      "Mix Time: 20\n",
+      "Time: 00:00:36 (HH:MM:SS)\n"
+     ]
+    }
+   ],
+   "source": [
+    "t = strftime(\"%H:%M:%S\",gmtime(t2-t1))\n",
+    "print(f\"Hit & Run Convex Polytope Sampling:\\nDimension: {d}\\nN: {N}\\nH&R Tries: {N*T}\\nVariance: {sigma_sq:.1f}\\nMix Time: {T}\\nTime: {t} (HH:MM:SS)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b76b2835",
+   "metadata": {},
+   "source": [
+    "Now we can reverse transform back to the original polytope. We get a Gaussian sample restricted to the polytope."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "5145a075",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = ratio2*X+cm2\n",
+    "X = X@la.inv(A)\n",
+    "X = ratio1*X+cm1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "d08df5fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SANITY: Gaussian samples inside polytope: True\n",
+      "SANITY: number of unique Gaussian samples: 1000\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('SANITY: Gaussian samples inside polytope:',np.all(in_domain(X, hull.equations, tol=tol)))\n",
+    "print('SANITY: number of unique Gaussian samples:',np.unique(X,axis=1).shape[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5960d41",
+   "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.9.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}