diff --git a/.gitignore b/.gitignore
index 1ce2748a..eee337c1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,3 +29,4 @@ debug.py
 docs/source/reference/release_notes.rst
 .vscode
 .hypothesis
+.venv
diff --git a/alea/ces_source.py b/alea/ces_source.py
new file mode 100644
index 00000000..5cbfb99e
--- /dev/null
+++ b/alea/ces_source.py
@@ -0,0 +1,334 @@
+from typing import Dict, Literal
+import numpy as np
+from scipy.interpolate import interp1d
+
+from inference_interface import template_to_multihist
+from blueice import HistogramPdfSource, Source
+from blueice.exceptions import PDFNotComputedException
+
+from multihist import Hist1d
+from alea.ces_transformation import Transformation
+
+MINIMAL_ENERGY_RESOLUTION = 0.05
+
+
+def safe_lookup(hist_obj):
+    "A Wrapper to make sure the lookup function returns 0 for out-of-range values"
+    original_lookup = hist_obj.lookup
+
+    def new_lookup(self, *args):
+        if isinstance(self, Hist1d):
+            coordinates = np.asarray(args[0])
+            in_range = (coordinates >= self.bin_edges[0]) & (coordinates <= self.bin_edges[-1])
+
+            if not in_range.any():
+                return np.zeros_like(coordinates)
+
+            clipped_coords = np.clip(coordinates, self.bin_edges[0], self.bin_edges[-1])
+            result = original_lookup(clipped_coords)
+            result[~in_range] = 0
+
+            return result
+        else:
+            for i, coords in enumerate(args):
+                coords = np.asarray(coords)
+                if (coords < self.bin_edges[i][0]).any() or (coords > self.bin_edges[i][-1]).any():
+                    return np.zeros_like(coords)
+            return original_lookup(*args)
+
+    hist_obj.lookup = new_lookup.__get__(hist_obj)
+    return hist_obj
+
+def rebin_interpolate_normalized(hist, new_edges):
+    """
+    Rebin a normalized histogram using interpolation, preserving normalization
+    
+    Parameters:
+    -----------
+    hist : Hist1d
+        Input histogram (assumed to be normalized)
+    new_edges : array-like
+        New bin edges
+        
+    Returns:
+    --------
+    Hist1d
+        New histogram with desired binning, properly normalized
+    """
+    from scipy.interpolate import interp1d
+    import numpy as np
+    from copy import deepcopy
+    
+    # First convert histogram values to density
+    density = hist.histogram / hist.bin_volumes()
+    
+    # Create interpolation function for the density
+    f = interp1d(hist.bin_centers, density, kind='linear', 
+                 bounds_error=False, fill_value=(density[0], density[-1]))
+    
+    # Get new bin centers
+    new_centers = 0.5 * (new_edges[1:] + new_edges[:-1])
+    
+    # Interpolate density at new bin centers
+    new_density = f(new_centers)
+    
+    # Convert back to histogram values
+    new_volumes = np.diff(new_edges)
+    new_hist = new_density * new_volumes
+    
+    # Create new histogram
+    result = deepcopy(hist)
+    result.histogram = new_hist
+    result.bin_edges = new_edges
+    
+    # Normalize to ensure total probability = 1
+    norm = np.sum(result.histogram * result.bin_volumes())
+    result.histogram = result.histogram / norm
+    
+    return result
+
+class CESTemplateSource(HistogramPdfSource):
+    def __init__(self, config: Dict, *args, **kwargs):
+        """Initialize the TemplateSource."""
+        # override the default interpolation method
+        if "pdf_interpolation_method" not in config:
+            config["pdf_interpolation_method"] = "piecewise"
+        super().__init__(config, *args, **kwargs)
+
+    def _load_inputs(self):
+        """Load the inputs needed for a histogram source from the config."""
+        self.ces_space = self.config["analysis_space"][0][1]
+        self.max_e = np.max(self.ces_space)
+        self.min_e = np.min(self.ces_space)
+        self.templatename = self.config["templatename"]
+        self.histname = self.config["histname"]
+
+    def _load_true_histogram(self):
+        """Load the true spectrum from the template (no transformation applied)"""
+        h = template_to_multihist(self.templatename, self.histname, hist_to_read=Hist1d)
+        return h
+
+    def _check_histogram(self, h: Hist1d):
+        """Check if the histogram has expected binning."""
+        # We only take 1d histogram in the ces axes
+        if not isinstance(h, Hist1d):
+            raise ValueError("Only Hist1d object is supported")
+        if self.ces_space.ndim != 1:
+            raise ValueError("Only 1d analysis space is supported")
+        if np.min(h.histogram) < 0:
+            raise AssertionError(
+                f"There are bins for source {self.templatename} with negative entries."
+            )
+
+        # check if the histogram overlaps the analysis space.
+        histogram_max = np.max(h.bin_edges)
+        histogram_min = np.min(h.bin_edges)
+        if self.min_e > histogram_max or self.max_e < histogram_min:
+            raise ValueError(
+                f"The histogram edge ({histogram_min},{histogram_max}) \
+                does not overlap with the analysis space ({self.min_e},{self.max_e}) \
+                remove this background please:)"
+            )
+
+    def _create_transformation(
+        self, transformation_type: Literal["smearing", "bias", "efficiency"]
+    ):
+        """Create a transformation object based on the transformation type."""
+        if self.config.get(f"apply_{transformation_type}", True):
+            parameters_key = f"{transformation_type}_parameters"
+            model_key = f"{transformation_type}_model"
+
+            if model_key not in self.config:
+                raise ValueError(f"{transformation_type.capitalize()} model is not provided")
+
+            if parameters_key not in self.config:
+                raise ValueError(f"{transformation_type.capitalize()} parameters are not provided")
+            else:
+                parameter_list = self.config[parameters_key]
+                # to get the values we need to iterate over the list and use self.config.get
+                combined_parameter_dict = {k: self.config.get(k) for k in parameter_list}
+
+            # Also take the peak_energy parameter if it is a mono smearing model
+            if "mono" in self.config[model_key]:
+                combined_parameter_dict["peak_energy"] = self.config["peak_energy"]
+
+            return Transformation(
+                parameters=combined_parameter_dict,
+                action=transformation_type,
+                model=self.config[model_key],
+            )
+        return None
+
+    def _transform_histogram(self, h: Hist1d):
+        """Apply the transformations to the histogram."""
+        # Create transformations for efficiency, smearing, and bias
+        smearing_transformation = self._create_transformation("smearing")
+        bias_transformation = self._create_transformation("bias")
+        efficiency_transformation = self._create_transformation("efficiency")
+
+        # Apply the transformations to the histogram
+        if smearing_transformation is not None:
+            h = smearing_transformation.apply_transformation(h)
+        if bias_transformation is not None:
+            h = bias_transformation.apply_transformation(h)
+        if efficiency_transformation is not None:
+            h = efficiency_transformation.apply_transformation(h)
+        return h
+
+    def _normalize_histogram(self, h: Hist1d):
+        """Normalize the histogram and calculate the rate of the source."""
+        # The binning MUST be uniform
+        # To avoid confusion, we always normalize the histogram
+        # So the unit is always events/year/keV, the rate multipliers are always in terms of that
+        total_integration = np.sum(h.histogram * h.bin_volumes())
+        h.histogram = h.histogram.astype(np.float64)
+        total_integration = total_integration.astype(np.float64)
+
+        h.histogram /= total_integration
+
+        # Apply the transformations to the histogram
+        h = self._transform_histogram(h)
+
+        # Calculate the integration of the histogram after all transformations
+        # Only from min_e to max_e
+        left_edges = h.bin_edges[:-1]
+        right_edges = h.bin_edges[1:]
+        outside_index = np.where((left_edges < self.min_e) | (right_edges > self.max_e))
+        h.histogram[outside_index] = 0
+        
+        # create a new histogram with self.ces_space as the binning
+        h = rebin_interpolate_normalized(h, self.ces_space)
+
+        self._bin_volumes = h.bin_volumes()
+        self._n_events_histogram = h.similar_blank_histogram()
+
+        # Note that it already does what "fraction_in_roi" does in the old code
+        # So no need to do again
+        integration_after_transformation_in_roi = np.sum(h.histogram * h.bin_volumes())
+
+        self.events_per_year = (
+            integration_after_transformation_in_roi * self.config["rate_multiplier"]
+        )
+        self.events_per_day = self.events_per_year / 365
+
+        # For pdf, we need to normalize the histogram to 1 again
+        return h, integration_after_transformation_in_roi
+
+    def build_histogram(self):
+        """Build the histogram of the source.
+
+        It's always called during the initialization of the source. So the attributes are set here.
+
+        """
+        print("Building histogram")
+        self._load_inputs()
+        h = self._load_true_histogram()
+        self._check_histogram(h)
+        h, frac_in_roi = self._normalize_histogram(h)
+        h_pdf = h
+        h_pdf /= frac_in_roi
+        self._pdf_histogram = h_pdf
+        self._pdf_histogram = safe_lookup(self._pdf_histogram)
+        self.set_dtype()
+
+    def simulate(self, n_events: int):
+        """Simulate events from the source.
+
+        Args:
+            n_events (int): The number of events to simulate.
+
+        Returns:
+            numpy.ndarray: The simulated events.
+
+        """
+        dtype = [
+            ("ces", float),
+            ("source", int),
+        ]
+        ret = np.zeros(n_events, dtype=dtype)
+        ret["ces"] = self._pdf_histogram.get_random(n_events)
+        return ret
+
+    def compute_pdf(self):
+        """Compute the PDF of the source."""
+        self.build_histogram()
+        Source.compute_pdf(self)
+
+    def pdf(self, *args):
+        """Interpolate the PDF of the source to return a function."""
+        # override the default interpolation method in blueice (RegularGridInterpolator)
+        if not self.pdf_has_been_computed:
+            raise PDFNotComputedException(
+                "%s: Attempt to call a PDF that has not been computed" % self
+            )
+
+        method = self.config["pdf_interpolation_method"]
+
+        if method == "linear":
+            if not hasattr(self, "_pdf_interpolator"):
+                # First call:
+                # Construct a linear interpolator between the histogram bins
+                self._pdf_interpolator = interp1d(
+                    self._pdf_histogram.bin_centers,
+                    self._pdf_histogram.histogram,
+                )
+            bcs = self._pdf_histogram.bin_centers
+            clipped_data = np.clip(args, bcs.min(), bcs.max())
+
+            return self._pdf_interpolator(np.transpose(clipped_data))
+
+        elif method == "piecewise":
+            return self._pdf_histogram.lookup(*args)
+
+        else:
+            raise NotImplementedError("PDF Interpolation method %s not implemented" % method)
+
+    def set_dtype(self):
+        """Set the data type of the source."""
+        self.dtype = [
+            ("ces", float),
+            ("source", int),
+        ]
+
+
+class CESMonoenergySource(CESTemplateSource):
+    def _load_inputs(self):
+        """Load needed inputs for a monoenergetic source from the config."""
+        self.ces_space = self.config["analysis_space"][0][1]
+        self.max_e = np.max(self.ces_space)
+        self.min_e = np.min(self.ces_space)
+        try:
+            self.mu = self.config["peak_energy"]
+        except KeyError:
+            raise ValueError("peak_energy is not provided in the config")
+
+    def _load_true_histogram(self):
+        """Create a fake histogram with a single peak at the peak energy."""
+        number_of_bins = int((self.max_e - self.min_e) / MINIMAL_ENERGY_RESOLUTION)
+        h = Hist1d(
+            data=np.repeat(self.mu, 1),
+            bins=number_of_bins,
+            range=(self.min_e, self.max_e),
+        )
+        h.histogram = h.histogram.astype(np.float64)
+        self.config["smearing_model"] = "mono_" + self.config["smearing_model"]
+        return h
+
+
+class CESFlatSource(CESTemplateSource):
+    def _load_inputs(self):
+        """Load needed inputs for a flat source from the config."""
+        self.ces_space = self.config["analysis_space"][0][1]
+        self.max_e = np.max(self.ces_space)
+        self.min_e = np.min(self.ces_space)
+
+    def _load_true_histogram(self):
+        """Create a histogram for the flat source."""
+        number_of_bins = int((self.max_e - self.min_e) / MINIMAL_ENERGY_RESOLUTION)
+        h = Hist1d(
+            data=np.linspace(self.min_e, self.max_e, number_of_bins),
+            bins=number_of_bins,
+            range=(self.min_e, self.max_e),
+        )
+        h.histogram = h.histogram.astype(np.float64)
+        return h
diff --git a/alea/ces_transformation.py b/alea/ces_transformation.py
new file mode 100644
index 00000000..a1a5eea1
--- /dev/null
+++ b/alea/ces_transformation.py
@@ -0,0 +1,157 @@
+from pydantic import BaseModel, validator
+from typing import Dict, Optional, Any, Literal, Callable
+import numpy as np
+from scipy import stats
+from copy import deepcopy
+from multihist import Hist1d
+
+
+def energy_res(energy, a=25.8, b=1.429):
+    """Return energy resolution in keV.
+
+    :param energy: true energy in keV :return: energy resolution in keV
+
+    """
+    # Reference for the values of a,b:
+    # xenon:xenonnt:analysis:ntsciencerun0:g1g2_update#standard_gaussian_vs_skew-gaussian_yue
+    return (np.sqrt(energy) * a + energy * b) / 100
+
+
+def smearing_mono_gaussian(
+    hist: Any,
+    smearing_a: float,
+    smearing_b: float,
+    peak_energy: float,
+    bins: Optional[np.ndarray] = None,
+):
+    """Smear a mono-energetic peak with a Gaussian."""
+
+    if bins is None:
+        # create an emptyzero histogram with the same binning as the input histogram
+        data = stats.norm.pdf(
+            hist.bin_centers,
+            loc=peak_energy,
+            scale=energy_res(peak_energy, smearing_a, smearing_b),
+        )
+        hist_smeared = Hist1d(data=np.zeros_like(data), bins=hist.bin_edges)
+        hist_smeared.histogram = data
+    else:
+        # use the bins that set by the user
+        bins = np.array(bins)
+        if bins.size <= 1:
+            raise ValueError("bins must have at least 2 elements")
+        bin_centers = 0.5 * (bins[1:] + bins[:-1])
+        data = stats.norm.pdf(
+            bin_centers,
+            loc=peak_energy,
+            scale=energy_res(peak_energy, smearing_a, smearing_b),
+        )
+        # create an empty histogram with the user-defined binning
+        hist_smeared = Hist1d(data=np.zeros_like(data), bins=bins)
+        hist_smeared.histogram = data
+
+    return hist_smeared
+
+
+def smearing_hist_gaussian(
+    hist: Any,
+    smearing_a: float,
+    smearing_b: float,
+    bins: Optional[np.ndarray] = None,
+):
+    """Smear a histogram with Gaussian. This allows for non-uniform histogram binning.
+
+    :param hist: the spectrum we want to smear :param bins: bin edges of the returned spectrum
+    :return: smeared histogram in the same unit as input spectrum
+
+    """
+    assert isinstance(hist, Hist1d), "Only Hist1d object is supported"
+    if bins is None:
+        # set the bins to the bin edges of the input histogram
+        bins = hist.bin_edges
+    elif bins.size <= 1:
+        raise ValueError("bins must have at least 2 elements")
+    bins = np.array(bins)
+
+    e_true_s, rates, bin_volumes = hist.bin_centers, hist.histogram, hist.bin_volumes()
+    mask = np.where(e_true_s > 0)
+    e_true_s = e_true_s[mask]
+    rates = rates[mask]
+    bin_volumes = bin_volumes[mask]
+
+    e_smeared_s = 0.5 * (bins[1:] + bins[:-1])
+    smeared = np.zeros_like(e_smeared_s)
+
+    for idx, e_smeared in enumerate(e_smeared_s):
+        probs = (
+            stats.norm.pdf(
+                e_smeared,
+                loc=e_true_s,
+                scale=energy_res(e_true_s, smearing_a, smearing_b),
+            )
+            * bin_volumes
+        )
+        smeared[idx] = np.sum(probs * rates)
+
+    hist_smeared = Hist1d.from_histogram(smeared, bins)
+
+    return hist_smeared
+
+
+def biasing_hist_arctan(hist: Any, A: float = 0.01977, k: float = 0.01707):
+    """Apply a constant bias to a histogram.
+
+    :param hist: the spectrum we want to apply the bias to :param bias: the bias to apply to the
+    spectrum :return: the spectrum with the bias applied
+
+    """
+    assert isinstance(hist, Hist1d), "Only Hist1d object is supported"
+    true_energy = hist.bin_centers
+    h_bias = deepcopy(hist)
+    bias_derivative = A * k / (1 + k**2 * true_energy**2)
+    h_bias.histogram *= 1 / (1 + bias_derivative)
+    return h_bias
+
+
+def efficiency_hist_constant(hist: Any, efficiency_constant: float):
+    """Apply a constant efficiency to a histogram.
+
+    :param hist: the spectrum we want to apply the efficiency to :param efficiency: the efficiency
+    to apply to the spectrum :return: the spectrum with the efficiency applied
+
+    """
+    assert isinstance(hist, Hist1d), "Only Hist1d object is supported"
+    assert 0 <= efficiency_constant <= 1, "Efficiency must be between 0 and 1"
+    hist.histogram = hist.histogram * efficiency_constant
+    return hist
+
+
+MODELS: Dict[str, Dict[str, Callable]] = {
+    "smearing": {
+        "gaussian": smearing_hist_gaussian,
+        "mono_gaussian": smearing_mono_gaussian,
+    },
+    "bias": {"arctan": biasing_hist_arctan},
+    "efficiency": {
+        "constant": efficiency_hist_constant,
+    },
+}
+
+
+# input: model name, parameters, transformation mode
+class Transformation(BaseModel):
+    parameters: Dict[str, float]
+    action: Literal["smearing", "bias", "efficiency"]
+    model: str
+
+    @validator("model")
+    @classmethod
+    def check_model(cls, v, values):
+        """Check if the model exists for the given action."""
+        if v not in MODELS[values["action"]]:
+            raise ValueError(f"Model {v} not found for action {values['action']}")
+        return v
+
+    def apply_transformation(self, histogram: Hist1d):
+        chosen_model = MODELS[self.action][self.model]
+        return chosen_model(histogram, **self.parameters)
diff --git a/alea/examples/configs/binned_ces.yaml b/alea/examples/configs/binned_ces.yaml
new file mode 100644
index 00000000..00c87dd1
--- /dev/null
+++ b/alea/examples/configs/binned_ces.yaml
@@ -0,0 +1,123 @@
+parameter_definition:
+  livetime:
+    nominal_value: 365.
+    ptype: livetime
+    fittable: false
+    description: Livetime in day
+
+  xe133_rate_multiplier:
+    nominal_value: 1000
+    ptype: rate
+    fittable: true
+    fit_limits:
+      - 0
+      - null
+    parameter_interval_bounds:
+      - 0
+      - 50
+    fit_guess: 1000
+
+  test_flat_rate_multiplier:
+    nominal_value: 1000
+    ptype: rate
+    fittable: ture
+    fit_limits:
+      - 0
+      - null
+    parameter_interval_bounds:
+      - 0
+      - 50
+    fit_guess: 1000
+
+  test_gaussian_rate_multiplier:
+    nominal_value: 300
+    ptype: rate
+    fittable: true
+    fit_limits:
+      - 0
+      - null
+    parameter_interval_bounds:
+      - 0
+      - 50
+    fit_guess: 300
+
+  smearing_a:
+    nominal_value: 24.8
+    ptype: shape
+    uncertainty: 0.1
+    relative_uncertainty: false
+    fittable: false
+    blueice_anchors:
+      - 24.8
+    fit_limits:
+      - 20
+      - 30
+    description: smearing shaping parameter
+
+  smearing_b:
+    nominal_value: 1.429
+    ptype: shape
+    uncertainty: 0.05
+    relative_uncertainty: false
+    fittable: false
+    blueice_anchors:
+      - 1.429
+    fit_limits:
+      - 1.2
+      - 1.6
+    description: smearing shaping parameter
+
+  efficiency_constant:
+    nominal_value: 0.8
+    ptype: shape
+    uncertainty: 0.05
+    relative_uncertainty: false
+    fittable: ture
+    blueice_anchors:
+      - 0.7
+      - 0.9
+
+likelihood_config:
+  template_folder: null  # will try to find the templates in alea
+  likelihood_terms:
+    - name: science_run_0
+      default_source_class: alea.ces_source.CESTemplateSource
+      likelihood_type: blueice.likelihood.BinnedLogLikelihood
+      analysis_space:
+        - ces: np.arange(0, 500, 1)
+      # smearing and efficiency are applied to all of the sources, unless overridden
+      apply_efficiency: true
+      efficiency_model: constant
+      efficiency_parameters:
+        - efficiency_constant
+      apply_smearing: true
+      smearing_model: gaussian
+      smearing_parameters:
+        - smearing_a
+        - smearing_b
+      apply_bias: false
+      livetime_parameter: livetime
+      slice_args: {}
+      source_wise_interpolation: false
+      sources:
+      - name: xe133
+        histname: xe133_template
+        parameters:
+          - xe133_rate_multiplier
+          - smearing_a
+          - smearing_b
+          - efficiency_constant
+        template_filename: xe133_template.ii.h5
+      - name: test_gaussian
+        class: alea.ces_source.CESMonoenergySource
+        peak_energy: 300
+        parameters:
+          - test_gaussian_rate_multiplier
+          - smearing_a
+          - smearing_b
+          - efficiency_constant
+      - name: test_flat
+        class: alea.ces_source.CESFlatSource
+        parameters:
+          - test_flat_rate_multiplier
+          - efficiency_constant
diff --git a/alea/examples/configs/unbinned_ces_simple.yaml b/alea/examples/configs/unbinned_ces_simple.yaml
new file mode 100644
index 00000000..e7147fc6
--- /dev/null
+++ b/alea/examples/configs/unbinned_ces_simple.yaml
@@ -0,0 +1,126 @@
+parameter_definition:
+  livetime:
+    nominal_value: 365.
+    ptype: livetime
+    fittable: false
+    description: Livetime in day
+
+  xe133_rate_multiplier:
+    nominal_value: 1000
+    ptype: rate
+    fittable: true
+    fit_limits:
+      - 0
+      - null
+    parameter_interval_bounds:
+      - 0
+      - 50
+    fit_guess: 1000
+
+  test_flat_rate_multiplier:
+    nominal_value: 1000
+    ptype: rate
+    fittable: ture
+    fit_limits:
+      - 0
+      - null
+    parameter_interval_bounds:
+      - 0
+      - 50
+    fit_guess: 1000
+
+  test_gaussian_rate_multiplier:
+    nominal_value: 300
+    ptype: rate
+    fittable: true
+    fit_limits:
+      - 0
+      - null
+    parameter_interval_bounds:
+      - 0
+      - 50
+    fit_guess: 300
+
+  smearing_a:
+    nominal_value: 24.8
+    ptype: shape
+    uncertainty: 0.1
+    relative_uncertainty: false
+    fittable: true
+    blueice_anchors:
+      - 20
+      - 24.8
+      - 30
+    fit_limits:
+      - 20
+      - 30
+    description: smearing shaping parameter
+
+  smearing_b:
+    nominal_value: 1.429
+    ptype: shape
+    uncertainty: 0.05
+    relative_uncertainty: false
+    fittable: true
+    blueice_anchors:
+      - 1.2
+      - 1.429
+      - 1.6
+    fit_limits:
+      - 1.2
+      - 1.6
+    description: smearing shaping parameter
+
+  efficiency_constant:
+    nominal_value: 0.8
+    ptype: shape
+    uncertainty: 0.05
+    relative_uncertainty: false
+    fittable: ture
+    blueice_anchors:
+      - 0.7
+      - 0.9
+
+likelihood_config:
+  template_folder: null  # will try to find the templates in alea
+  likelihood_terms:
+    - name: science_run_0
+      default_source_class: alea.ces_source.CESTemplateSource
+      likelihood_type: blueice.likelihood.UnbinnedLogLikelihood
+      analysis_space:
+        - ces: np.arange(0, 500, 1)
+      # smearing and efficiency are applied to all of the sources, unless overridden
+      apply_efficiency: true
+      efficiency_model: constant
+      efficiency_parameters:
+        - efficiency_constant
+      apply_smearing: true
+      smearing_model: gaussian
+      smearing_parameters:
+        - smearing_a
+        - smearing_b
+      apply_bias: false
+      livetime_parameter: livetime
+      slice_args: {}
+      sources:
+      - name: xe133
+        histname: xe133_template
+        parameters:
+          - xe133_rate_multiplier
+          - smearing_a
+          - smearing_b
+          - efficiency_constant
+        template_filename: xe133_template.ii.h5
+      - name: test_gaussian
+        class: alea.ces_source.CESMonoenergySource
+        peak_energy: 300
+        parameters:
+          - test_gaussian_rate_multiplier
+          - smearing_a
+          - smearing_b
+          - efficiency_constant
+      - name: test_flat
+        class: alea.ces_source.CESFlatSource
+        parameters:
+          - test_flat_rate_multiplier
+          - efficiency_constant
diff --git a/alea/examples/templates/xe133_template.ii.h5 b/alea/examples/templates/xe133_template.ii.h5
new file mode 100644
index 00000000..a1df90e1
Binary files /dev/null and b/alea/examples/templates/xe133_template.ii.h5 differ
diff --git a/alea/models/blueice_extended_model.py b/alea/models/blueice_extended_model.py
index e6fd5d54..463eb12d 100644
--- a/alea/models/blueice_extended_model.py
+++ b/alea/models/blueice_extended_model.py
@@ -335,7 +335,8 @@ def _build_ll_from_config(
         # Iterate through each likelihood term in the configuration
         for config in likelihood_config["likelihood_terms"]:
             blueice_config = self._process_blueice_config(config, template_folder_list)
-            blueice_config.setdefault("source_wise_interpolation", True)
+            blueice_config["source_wise_interpolation"] = config.get("source_wise_interpolation", True)
+            print(blueice_config["source_wise_interpolation"])
 
             likelihood_class = cast(Callable, locate(config["likelihood_type"]))
             if likelihood_class is None:
diff --git a/notebooks/4_ces_inference.ipynb b/notebooks/4_ces_inference.ipynb
new file mode 100644
index 00000000..bb9b3606
--- /dev/null
+++ b/notebooks/4_ces_inference.ipynb
@@ -0,0 +1,750 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 4.Using the 1D inference\n",
+    "In this tutorial, we will show how to:\n",
+    "- Define sources and transformations for 1D spectra\n",
+    "- Use the 1D inference to fit with a CES spectrum \n",
+    "- Search for a monoenergetic signal from Xe133 and flat backgrounds"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import sys\n",
+    "import scipy.stats as stats\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# use the latest inference_interface to allow 1d hist!\n",
+    "sys.path.insert(0, \"/home/yuem/xenon_package/inference_interface\")\n",
+    "from inference_interface import multihist_to_template, template_to_multihist\n",
+    "from alea.utils import get_file_path\n",
+    "from alea.models import BlueiceExtendedModel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.1 Load the example yaml config and have a look\n",
+    "In the example we include 3 components:\n",
+    "- Xe133: a histogram based source\n",
+    "- test_gaussian: a monoenergic source\n",
+    "- test_flat: a flat source\n",
+    "\n",
+    "#### 4.1a parameter_defination\n",
+    "This part is all the same as what we did in the previous notebooks - include all of your parameters and their information\n",
+    "\n",
+    "#### 4.1b likelihood_config\n",
+    "Here we need to do a little bit more:\n",
+    "- Define the transformations applied, the model for those transformations, and related parameters. For details you can check `ces_transformation.py`, in which we include the basic transformations (efficiency, smearing and bias) \n",
+    "- For each kind of source, we need to provide the specific information needed\n",
+    "\n",
+    "For example, here we set:\n",
+    "- apply_efficiency = True, efficiency_model = \"constant\", efficiency_parameters = \"efficiency\"\n",
+    "\n",
+    "The transformation parameter(s) must fit the chosen model and must appear in the parameter defination. Most of the time they should appear as shape parameteres with blueice anchors. Otherwise the speed of the fitting will be decreased dramatically."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'template_folder': None,\n",
+       " 'likelihood_terms': [{'name': 'science_run_0',\n",
+       "   'default_source_class': 'alea.ces_source.CESTemplateSource',\n",
+       "   'likelihood_type': 'blueice.likelihood.UnbinnedLogLikelihood',\n",
+       "   'analysis_space': [{'ces': 'np.arange(0, 500, 1)'}],\n",
+       "   'apply_efficiency': True,\n",
+       "   'efficiency_model': 'constant',\n",
+       "   'efficiency_parameters': ['efficiency_constant'],\n",
+       "   'apply_smearing': True,\n",
+       "   'smearing_model': 'gaussian',\n",
+       "   'smearing_parameters': ['smearing_a', 'smearing_b'],\n",
+       "   'apply_bias': False,\n",
+       "   'livetime_parameter': 'livetime',\n",
+       "   'slice_args': {},\n",
+       "   'sources': [{'name': 'xe133',\n",
+       "     'histname': 'xe133_template',\n",
+       "     'parameters': ['xe133_rate_multiplier',\n",
+       "      'smearing_a',\n",
+       "      'smearing_b',\n",
+       "      'efficiency_constant'],\n",
+       "     'template_filename': 'xe133_template.ii.h5'},\n",
+       "    {'name': 'test_gaussian',\n",
+       "     'class': 'alea.ces_source.CESMonoenergySource',\n",
+       "     'peak_energy': 300,\n",
+       "     'parameters': ['test_gaussian_rate_multiplier',\n",
+       "      'smearing_a',\n",
+       "      'smearing_b',\n",
+       "      'efficiency_constant']},\n",
+       "    {'name': 'test_flat',\n",
+       "     'class': 'alea.ces_source.CESFlatSource',\n",
+       "     'parameters': ['test_flat_rate_multiplier', 'efficiency_constant']}]}]}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import yaml\n",
+    "\n",
+    "example_model_config_path = get_file_path(\"unbinned_ces_simple.yaml\")\n",
+    "with open(example_model_config_path, \"r\") as f:\n",
+    "    example_model_config = yaml.load(f, Loader=yaml.FullLoader)\n",
+    "example_model_config[\"likelihood_config\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's look into the sources. The specific information (other than rate multipliers) needed by those basic sources are:\n",
+    "- histogram-based: template_filename\n",
+    "- flat: None\n",
+    "- monoenergetic: peak_energy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[{'name': 'xe133',\n",
+       "  'histname': 'xe133_template',\n",
+       "  'parameters': ['xe133_rate_multiplier',\n",
+       "   'smearing_a',\n",
+       "   'smearing_b',\n",
+       "   'efficiency_constant'],\n",
+       "  'template_filename': 'xe133_template.ii.h5'},\n",
+       " {'name': 'test_gaussian',\n",
+       "  'class': 'alea.ces_source.CESMonoenergySource',\n",
+       "  'peak_energy': 300,\n",
+       "  'parameters': ['test_gaussian_rate_multiplier',\n",
+       "   'smearing_a',\n",
+       "   'smearing_b',\n",
+       "   'efficiency_constant']},\n",
+       " {'name': 'test_flat',\n",
+       "  'class': 'alea.ces_source.CESFlatSource',\n",
+       "  'parameters': ['test_flat_rate_multiplier', 'efficiency_constant']}]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_model_config[\"likelihood_config\"][\"likelihood_terms\"][0][\"sources\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.2 Build the model based on the config\n",
+    "This is all the same as previous notebooks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:   0%|          | 0/18 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:   6%|▌         | 1/18 [00:00<00:14,  1.18it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  11%|█         | 2/18 [00:01<00:14,  1.12it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n",
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  17%|█▋        | 3/18 [00:02<00:13,  1.08it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  22%|██▏       | 4/18 [00:03<00:12,  1.11it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  28%|██▊       | 5/18 [00:04<00:11,  1.14it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  33%|███▎      | 6/18 [00:05<00:11,  1.06it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  39%|███▉      | 7/18 [00:06<00:09,  1.10it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  44%|████▍     | 8/18 [00:07<00:08,  1.14it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  56%|█████▌    | 10/18 [00:07<00:05,  1.52it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  61%|██████    | 11/18 [00:08<00:04,  1.45it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  67%|██████▋   | 12/18 [00:09<00:04,  1.36it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  72%|███████▏  | 13/18 [00:10<00:03,  1.33it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  78%|███████▊  | 14/18 [00:11<00:03,  1.29it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  83%|████████▎ | 15/18 [00:12<00:02,  1.28it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  89%|████████▉ | 16/18 [00:12<00:01,  1.27it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  94%|█████████▍| 17/18 [00:13<00:00,  1.26it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core: 100%|██████████| 18/18 [00:14<00:00,  1.24it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "example_model = BlueiceExtendedModel.from_config(example_model_config_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['xe133', 'test_gaussian', 'test_flat']"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "source_name_list = example_model.get_source_name_list(likelihood_name=\"science_run_0\")\n",
+    "source_name_list"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "By looking at the expectation of sources, we can find that the efficiency (nominal value=0.9) is applied"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'test_flat': 799.9999999999999,\n",
+       " 'test_gaussian': 240.00000000000006,\n",
+       " 'xe133': 800.000721781116}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_model.get_expectation_values()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.3 Simulate some data and fit with it\n",
+    "We can see that the smearing is correctly applied. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = example_model.generate_data()\n",
+    "example_model.data = data\n",
+    "plt.hist(data[\"science_run_0\"][\"ces\"], bins=np.linspace(0, 500, 100), histtype=\"step\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The fitted values are consistent with the nominal values that we set (1000, 1000 and 300)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'livetime': 365.0,\n",
+       " 'xe133_rate_multiplier': 1058.2538790745741,\n",
+       " 'test_flat_rate_multiplier': 965.1163259805631,\n",
+       " 'test_gaussian_rate_multiplier': 345.6196664730858,\n",
+       " 'smearing_a': 24.865002715009357,\n",
+       " 'smearing_b': 1.4310471172694272,\n",
+       " 'efficiency_constant': 0.7948481366164633}"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "best_fit, max_ll = example_model.fit()\n",
+    "best_fit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.4 Find the confidence interval of fitted rate_multipliers\n",
+    "It's the same as what we did in `2_fitting_and_ci`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "20it [00:02,  7.28it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "fitted_gs_rate = best_fit[\"test_gaussian_rate_multiplier\"]\n",
+    "gs_rates = np.linspace(0.8 * fitted_gs_rate, 1.2 * fitted_gs_rate, 20)\n",
+    "ll_vals_c = np.zeros((len(gs_rates)))\n",
+    "\n",
+    "for i, gs_rate in tqdm(enumerate(gs_rates)):\n",
+    "    _, ll_val_c = example_model.fit(test_gaussian_rate_multiplier=gs_rate)\n",
+    "    ll_vals_c[i] = ll_val_c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'q(s)')"
+      ]
+     },
+     "execution_count": 50,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "x = gs_rates\n",
+    "y = 2 * (max_ll - ll_vals_c)\n",
+    "confidence_level = 0.9\n",
+    "# Plot\n",
+    "plt.plot(x, y)\n",
+    "plt.axhline(\n",
+    "    stats.chi2(1).ppf(confidence_level),\n",
+    "    label=\"Asymptotic critical value (90% CL)\",\n",
+    "    c=\"orange\",\n",
+    "    ls=\"--\",\n",
+    ")\n",
+    "\n",
+    "plt.axvline(fitted_gs_rate, label=f\"Best Fit: {fitted_gs_rate:.1f}\", c=\"red\", ls=\"--\")\n",
+    "plt.ylim(0, 8)\n",
+    "plt.legend()\n",
+    "plt.xlabel(\"test_gaussian rate multiplier\")\n",
+    "plt.ylabel(\"q(s)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4.5 Find the fitted smearing model\n",
+    "As we mentioned before, the transformation parameters can also be set as \"fittable\" and therefore we can check if the data conflicts with the transformations. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "10it [00:10,  1.09s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "a_vals = np.linspace(0.99 * best_fit[\"smearing_a\"], 1.01 * best_fit[\"smearing_a\"], 10)\n",
+    "b_vals = np.linspace(0.95 * best_fit[\"smearing_b\"], 1.05 * best_fit[\"smearing_b\"], 10)\n",
+    "\n",
+    "ll_vals_c = np.zeros((len(a_vals), len(b_vals)))\n",
+    "\n",
+    "for i, a in tqdm(enumerate(a_vals)):\n",
+    "    for j, b in enumerate(b_vals):\n",
+    "        _, ll_val_c = example_model.fit(smearing_a=a, smearing_b=b)\n",
+    "        ll_vals_c[i, j] = ll_val_c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.contourf(a_vals, b_vals, 2 * (max_ll - ll_vals_c).T, cmap=\"viridis\")\n",
+    "plt.colorbar(label=\"$q(s)$\")\n",
+    "\n",
+    "contours = plt.contour(\n",
+    "    a_vals, b_vals, 2 * (max_ll - ll_vals_c).T, colors=\"white\", linewidths=1, levels=[1, 4, 9]\n",
+    ")\n",
+    "sigma_levels = {1: r\"1$\\sigma$\", 4: r\"2$\\sigma$\", 9: r\"3$\\sigma$\"}\n",
+    "plt.clabel(contours, inline=True, fontsize=10, fmt=sigma_levels)\n",
+    "\n",
+    "plt.scatter(best_fit[\"smearing_a\"], best_fit[\"smearing_b\"], color=\"red\")\n",
+    "plt.xlabel(\"Smearing Parameter a\")\n",
+    "plt.ylabel(\"Smearing Parameter b\")\n",
+    "plt.title(\"$q(s)$\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/notebooks/5_ces_binned.ipynb b/notebooks/5_ces_binned.ipynb
new file mode 100644
index 00000000..3c6de846
--- /dev/null
+++ b/notebooks/5_ces_binned.ipynb
@@ -0,0 +1,413 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import sys\n",
+    "import scipy.stats as stats\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# use the latest inference_interface to allow 1d hist!\n",
+    "sys.path.insert(0, \"/home/yuem/xenon_package/inference_interface\")\n",
+    "sys.path.insert(0, \"/home/yuem/xenon_package/blueice\")\n",
+    "from inference_interface import multihist_to_template, template_to_multihist\n",
+    "from alea.utils import get_file_path\n",
+    "from alea.models import BlueiceExtendedModel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'template_folder': None,\n",
+       " 'likelihood_terms': [{'name': 'science_run_0',\n",
+       "   'default_source_class': 'alea.ces_source.CESTemplateSource',\n",
+       "   'likelihood_type': 'blueice.likelihood.BinnedLogLikelihood',\n",
+       "   'analysis_space': [{'ces': 'np.arange(0, 500, 1)'}],\n",
+       "   'apply_efficiency': True,\n",
+       "   'efficiency_model': 'constant',\n",
+       "   'efficiency_parameters': ['efficiency_constant'],\n",
+       "   'apply_smearing': True,\n",
+       "   'smearing_model': 'gaussian',\n",
+       "   'smearing_parameters': ['smearing_a', 'smearing_b'],\n",
+       "   'apply_bias': False,\n",
+       "   'livetime_parameter': 'livetime',\n",
+       "   'slice_args': {},\n",
+       "   'source_wise_interpolation': False,\n",
+       "   'sources': [{'name': 'xe133',\n",
+       "     'histname': 'xe133_template',\n",
+       "     'parameters': ['xe133_rate_multiplier',\n",
+       "      'smearing_a',\n",
+       "      'smearing_b',\n",
+       "      'efficiency_constant'],\n",
+       "     'template_filename': 'xe133_template.ii.h5'},\n",
+       "    {'name': 'test_gaussian',\n",
+       "     'class': 'alea.ces_source.CESMonoenergySource',\n",
+       "     'peak_energy': 300,\n",
+       "     'parameters': ['test_gaussian_rate_multiplier',\n",
+       "      'smearing_a',\n",
+       "      'smearing_b',\n",
+       "      'efficiency_constant']},\n",
+       "    {'name': 'test_flat',\n",
+       "     'class': 'alea.ces_source.CESFlatSource',\n",
+       "     'parameters': ['test_flat_rate_multiplier', 'efficiency_constant']}]}]}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import yaml\n",
+    "\n",
+    "example_model_config_path = get_file_path(\"binned_ces.yaml\")\n",
+    "with open(example_model_config_path, \"r\") as f:\n",
+    "    example_model_config = yaml.load(f, Loader=yaml.FullLoader)\n",
+    "example_model_config[\"likelihood_config\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'name': 'science_run_0', 'default_source_class': 'alea.ces_source.CESTemplateSource', 'likelihood_type': 'blueice.likelihood.BinnedLogLikelihood', 'analysis_space': [{'ces': 'np.arange(0, 500, 1)'}], 'apply_efficiency': True, 'efficiency_model': 'constant', 'efficiency_parameters': ['efficiency_constant'], 'apply_smearing': True, 'smearing_model': 'gaussian', 'smearing_parameters': ['smearing_a', 'smearing_b'], 'apply_bias': False, 'livetime_parameter': 'livetime', 'slice_args': {}, 'source_wise_interpolation': False, 'sources': [{'name': 'xe133', 'histname': 'xe133_template', 'parameters': ['xe133_rate_multiplier', 'smearing_a', 'smearing_b', 'efficiency_constant'], 'template_filename': 'xe133_template.ii.h5'}, {'name': 'test_gaussian', 'class': 'alea.ces_source.CESMonoenergySource', 'peak_energy': 300, 'parameters': ['test_gaussian_rate_multiplier', 'smearing_a', 'smearing_b', 'efficiency_constant']}, {'name': 'test_flat', 'class': 'alea.ces_source.CESFlatSource', 'parameters': ['test_flat_rate_multiplier', 'efficiency_constant']}]}\n",
+      "False\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:   0%|          | 0/2 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core:  50%|█████     | 1/2 [00:06<00:06,  6.22s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building histogram\n",
+      "Building histogram\n",
+      "Building histogram\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Computing/loading models on one core: 100%|██████████| 2/2 [00:12<00:00,  6.18s/it]\n",
+      "building data generators: 100%|██████████| 1/1 [00:00<00:00, 358.79it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "example_model = BlueiceExtendedModel.from_config(example_model_config_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'test_flat': 999.9999999999999, 'test_gaussian': 300.0, 'xe133': 1000.0}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_model.get_expectation_values()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.],\n",
+       "       [0., 0., 0., ..., 0., 0., 0.]])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# n_model_events\n",
+    "example_model.likelihood_list[0].n_model_events"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[9.04773443e-007, 1.70022150e-006, 1.44361290e-006, ...,\n",
+       "        2.22874512e-016, 1.23613836e-016, 6.80635389e-017],\n",
+       "       [1.70928755e-266, 9.90163184e-265, 5.65851486e-263, ...,\n",
+       "        6.90529806e-116, 4.76078521e-117, 3.23801449e-118],\n",
+       "       [2.03167054e-003, 2.02884836e-003, 2.02791341e-003, ...,\n",
+       "        1.15496934e-003, 1.09184961e-003, 1.02823755e-003]])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#ps: pmf grid (binned)\n",
+    "example_model.likelihood_list[0].ps"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1., 1., 1.])"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_model.likelihood_list[0].base_model.expected_events()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([1., 1., 1.]),\n",
+       " array([[9.04773443e-007, 1.70022150e-006, 1.44361290e-006, ...,\n",
+       "         2.22874512e-016, 1.23613836e-016, 6.80635389e-017],\n",
+       "        [1.70928755e-266, 9.90163184e-265, 5.65851486e-263, ...,\n",
+       "         6.90529806e-116, 4.76078521e-117, 3.23801449e-118],\n",
+       "        [2.03167054e-003, 2.02884836e-003, 2.02791341e-003, ...,\n",
+       "         1.15496934e-003, 1.09184961e-003, 1.02823755e-003]]),\n",
+       " array([[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]]))"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#mus: rate for each source\n",
+    "example_model.likelihood_list[0]._compute_single_pdf()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = example_model.generate_data()\n",
+    "example_model.data = data\n",
+    "plt.hist(data[\"science_run_0\"][\"ces\"], bins=np.linspace(0, 500, 100), histtype=\"step\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'livetime': 365.0,\n",
+       " 'xe133_rate_multiplier': 1033.490760614393,\n",
+       " 'test_flat_rate_multiplier': 954.6427541651263,\n",
+       " 'test_gaussian_rate_multiplier': 328.88660448450196,\n",
+       " 'smearing_a': 24.8,\n",
+       " 'smearing_b': 1.429,\n",
+       " 'efficiency_constant': 0.8091246788074896}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "best_fit, max_ll = example_model.fit()\n",
+    "best_fit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "20it [00:01, 11.67it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "fitted_gs_rate = best_fit[\"test_gaussian_rate_multiplier\"]\n",
+    "gs_rates = np.linspace(0.8 * fitted_gs_rate, 1.2 * fitted_gs_rate, 20)\n",
+    "ll_vals_c = np.zeros((len(gs_rates)))\n",
+    "\n",
+    "for i, gs_rate in tqdm(enumerate(gs_rates)):\n",
+    "    _, ll_val_c = example_model.fit(test_gaussian_rate_multiplier=gs_rate)\n",
+    "    ll_vals_c[i] = ll_val_c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'q(s)')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "x = gs_rates\n",
+    "y = 2 * (max_ll - ll_vals_c)\n",
+    "confidence_level = 0.9\n",
+    "# Plot\n",
+    "plt.plot(x, y)\n",
+    "plt.axhline(\n",
+    "    stats.chi2(1).ppf(confidence_level),\n",
+    "    label=\"Asymptotic critical value (90% CL)\",\n",
+    "    c=\"orange\",\n",
+    "    ls=\"--\",\n",
+    ")\n",
+    "\n",
+    "plt.axvline(fitted_gs_rate, label=f\"Best Fit: {fitted_gs_rate:.1f}\", c=\"red\", ls=\"--\")\n",
+    "plt.ylim(0, 8)\n",
+    "plt.legend()\n",
+    "plt.xlabel(\"test_gaussian rate multiplier\")\n",
+    "plt.ylabel(\"q(s)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.20"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}