@@ -1,12 +1,25 @@
 from pathlib import Path
 
+from diffpy.srfit.fitbase import Profile
 from diffpy.srfit.fitbase.parameter import Parameter
 from diffpy.srfit.fitbase.parameterset import ParameterSet
 from diffpy.srfit.pdf.pdfparser import PDFParser
 from diffpy.srfit.structure import struToParameterSet
 from diffpy.structure import Structure
 
 
+class RefinenableModel(ParameterSet):
+    """
+    A RefinenableModel instance provides access to both the ParameterSet
+    and the underlying model object.
+    """
+
+    def __init__(self, name):
+        super().__init__(name=name)
+        self.model = None
+        self.parameters = None
+
+
 class ParameterParser:
     def __init__(self):
         pass
@@ -28,15 +41,22 @@ def _parse_pdf(
         pass
         parser = PDFParser()
         parser.parseFile(profile_file)
+        profile = Profile()
+        profile.loadParsedData(parser)
         parameter_values = parser.getData()
         parameter_names = ["x", "y", "dx", "dy"]
         parameter_set = _construct_parameterset(
             parameter_names, parameter_values, parset_name
         )
+        profile_model = RefinenableModel(name=parset_name)
+        profile_model.model = profile
+        profile_model.parameters = parameter_set
         meta = dict(parser.getMetaData())
-        return parameter_set, meta
+        return profile_model, meta
 
-    def _parse_structure(self, structure_file: str):
+    def _parse_structure(
+        self, structure_file: str, parset_name: str = "structure_parameterset"
+    ):
         if not Path(structure_file).exists():
             raise FileNotFoundError(
                 self.MISSING_FILE_WARNING.format(
@@ -45,35 +65,16 @@ def _parse_structure(self, structure_file: str):
             )
         stru = Structure()
         stru.read(structure_file)
-        structure_parameterset = struToParameterSet(
-            "structure_parameterset", stru
+        stru_diffpy_parset = struToParameterSet(parset_name, stru)
+        structure_mdel = RefinenableModel(name=parset_name)
+        structure_mdel.model = stru
+        structure_mdel.parameters = ParameterSet(name=parset_name)
+        structure_mdel.parameters.addParameterSet(
+            stru_diffpy_parset.getLattice()
         )
-        return structure_parameterset
-
-
-class ParameterAdapter:
-    """
-    A ParameterAdapter class contains methods to adapt parameters of
-    variables format to the standard format used in diffpy
-    """
-
-    def __init__(self):
-        pass
-
-    def _adapt_string(self, parameter: str):
-        pass
-
-    def _adapt_code(self, function_code: str):
-        pass
-
-    def _adapt_special(self, special_parameter: str):
-        pass
-
-    def _adapt_structure_file(self, phase_file: str):
-        pass
-
-    def _adapt_profile_file(self, profile_file: str):
-        pass
+        for atom_parset in stru_diffpy_parset.getScatterers():
+            structure_mdel.parameters.addParameterSet(atom_parset)
+        return structure_mdel
 
 
 def _construct_parameterset(names, values, parset_name):
 
@@ -1,7 +1,12 @@
+from collections import OrderedDict
+
+from scipy.optimize import leastsq
+
+from diffpy.srfit.fitbase import FitContribution, FitRecipe, Profile
 from diffpy.srfit.fitbase.parameterset import ParameterSet
 
 
-class RefinementSession(ParameterSet):
+class RefinementSession:
     """
     A refinement session class that manages the refinement process.
 
@@ -25,23 +30,51 @@ class RefinementSession(ParameterSet):
     """
 
     def __init__(self):
-        self.loss_functions = []
-        self.loss_function = None
+        self.main_parameter_set = ParameterSet(name="main_parameter_set")
+        self.calculators = []
+        self.contributions = OrderedDict()
+
+    def add_parameterSet(self, parset):
+        """Add a ParameterSet to the refinement session."""
+        self.main_parameter_set.addParameterSet(parset)
 
-    def _prepare_variables(self):
-        """Prepare variables for refinement.
+    def add_parameter(self, parameter):
+        """Add a Parameter to the refinement session."""
+        self.main_parameter_set.addParameter(parameter)
 
-        Convert the literals into builders before make the equation"""
+    def add_function(self, name, expression=None, ns={}):
         pass
 
-    def register_loss_function(self):
-        """Register the loss function for refinement."""
+    def add_calculator(self, calculator):
         pass
 
-    def set_master_loss_function(self, name):
-        """set the master loss function for refinement."""
-        self.master_loss_function = name
+    def add_profile(self, name=None, profile=None, x=None, y=None, dy=None):
+        if profile is None:
+            profile = Profile()
+            profile.x = x
+            profile.y = y
+            if dy is not None:
+                profile.dy = dy
+        contribution = FitContribution(name=name)
+        contribution.setProfile(profile, xname=profile.x.name)
+        self.contributions[name] = contribution
 
-    def refine(self):
-        """Perform the refinement."""
-        pass
+    def set_profile_equation(self, profile_name, expression):
+        self.contributions[profile_name].setEquation(expression)
+
+    def set_profile_weights(self, names, weights):
+        self.recipe = FitRecipe()
+        for name, weight in zip(names, weights):
+            self.recipe.addContribution(
+                self.contributions[name], weight=weight
+            )
+
+    def refine(self, var_names, initial_values):
+        for name, value in zip(var_names, initial_values):
+            self.main_parameter_set.parameters[name].setValue(value)
+        for name in var_names:
+            self.recipe.addVar(self.main_parameter_set.parameters[name])
+        self.recipe.fix("all")
+        for name in var_names:
+            self.recipe.free(name)
+            leastsq(self.recipe.residual, self.recipe.values)
@@ -0,0 +1,67 @@
+from diffpy.apps.refinebase.refinable_model import (
+    ParameterParser,
+)
+
+
+def test_parse_pdf():
+    # C1: reading a valid .gr file
+    #  Expect return  valid ParameterSet and meta data
+    profile_path = "tests/data/Ni.gr"
+    parser = ParameterParser()
+    profile_model, meta = parser._parse_pdf(
+        profile_path, parset_name="profile_parameterset"
+    )
+    expected_parameter_names = ["x", "y", "dx", "dy"]
+    actual_parameter_names = [par.name for par in profile_model.parameters]
+    assert set(actual_parameter_names) == set(expected_parameter_names)
+    expected_meta = {
+        "stype": "X",
+        "qmin": 0.5,
+        "qmax": 25.0,
+        "filename": "tests/data/Ni.gr",
+        "bank": 0,
+        "nbanks": 1,
+    }
+    actual_meta = meta
+    assert actual_meta == expected_meta
+
+
+def test_parse_structure():
+    # C1: reading a valid .cif file
+    #  Expect return valid ParameterSet
+    structure_path = "tests/data/Ni.cif"
+    parser = ParameterParser()
+    structure_model = parser._parse_structure(structure_path)
+    expected_parameter_names = ["a", "b", "c", "alpha", "beta", "gamma"]
+    actual_parameter_names = [
+        name
+        for name in structure_model.parameters._parsets[
+            "lattice"
+        ]._parameters.keys()
+    ]
+    assert set(actual_parameter_names) == set(expected_parameter_names)
+    expected_atom_parameter_names = [
+        "x",
+        "y",
+        "z",
+        "Uiso",
+        "Biso",
+        "occ",
+        "occupancy",
+    ]
+    expected_atom_parameter_names += [
+        f"U{j+1}{k+1}" for j in range(3) for k in range(3)
+    ]
+    expected_atom_parameter_names += [
+        f"B{j+1}{k+1}" for j in range(3) for k in range(3)
+    ]
+    for i in range(len(structure_model.model)):
+        actual_atom_parameter_names = [
+            name
+            for name in structure_model.parameters._parsets[
+                f"Ni{i}"
+            ]._parameters.keys()
+        ]
+        assert set(actual_atom_parameter_names) == set(
+            expected_atom_parameter_names
+        )
@@ -0,0 +1,36 @@
+import numpy
+
+from diffpy.apps.refinebase.refinement_session import RefinementSession
+
+
+def test_refinement_session():
+    # C1: Refinement session without additional calculator or functions
+    session = RefinementSession()
+    xobs = numpy.linspace(-numpy.pi, numpy.pi, 100)
+    yobs = numpy.sin(xobs) + 0.1 * numpy.random.normal(size=xobs.shape)
+    session.add_profile(name="profile", x=xobs, y=yobs)
+    session.add_parameter(name="x", delegates_to="profile.x")
+    session.set_profile_equation(profile="profile", expression="A*sin(a*x)")
+    session.set_profile_weights(["profile"], [1.0])
+    session.refine(name=["A", "a"], initial_values=[1.0, 0.5])
+
+    # C2: Refinement session with one PDFCalculator
+    # parser = ParameterParser()
+    # profile_path = "tests/data/Ni.gr"
+    # structure_path = "tests/data/Ni.cif"
+    # profile_model, profile_meta = parser._parse_pdf(profile_path)
+    # structure_model = parser._parse_structure(structure_path)
+
+    # session = RefinementSession()
+    # session.addParameterSet(profile_model.parameters)
+    # session.addParameterSet(structure_model.parameters)
+    # session.addParameter(
+    #     ParameterAdapter(
+    #         name="g1",
+    #         callable=lambda: PDFCalculator(structure_model.model)[1]
+    #     )
+    # )
+    # session.addParameter(ParameterAdapter(name="s1", value=1.0))
+    # session.register_loss_function(name="l1", expression="s1*g1")
+    # session.set_master_loss_function(name="l1")
+    # session.refine()