diff --git a/modules/pmi/examples/atomistic.py b/modules/pmi/examples/atomistic.py
index e10c7d6e54..6b102a0296 100644
--- a/modules/pmi/examples/atomistic.py
+++ b/modules/pmi/examples/atomistic.py
@@ -3,6 +3,7 @@
 with a secondary structure elastic network to speed things up.
 """
 
+from __future__ import print_function
 import IMP
 import RMF
 import IMP.atom
@@ -15,6 +16,10 @@
 import sys
 
 IMP.setup_from_argv(sys.argv, "Simulation of an atomic system")
+if IMP.get_is_quick_test():
+    print("This example is too slow to test in debug mode - run without")
+    print("internal tests enabled, or without the --run-quick-test flag")
+    sys.exit(0)
 
 # Setup System and add a State
 mdl = IMP.Model()
diff --git a/modules/pmi/examples/automatic.py b/modules/pmi/examples/automatic.py
index 31b24e2076..d392fb3b4a 100644
--- a/modules/pmi/examples/automatic.py
+++ b/modules/pmi/examples/automatic.py
@@ -2,6 +2,7 @@
 """This script shows how to use the BuildSystem macro to construct large systems with minimal code
 """
 
+from __future__ import print_function
 import IMP
 import RMF
 import IMP.atom
@@ -16,6 +17,10 @@
 import sys
 
 IMP.setup_from_argv(sys.argv, "Automatic setup of a large system")
+if IMP.get_is_quick_test():
+    print("This example is too slow to test in debug mode - run without")
+    print("internal tests enabled, or without the --run-quick-test flag")
+    sys.exit(0)
 
 # This is the topology table format.
 #  It allows you to create many components in a simple way
diff --git a/modules/pmi/examples/multiscale.py b/modules/pmi/examples/multiscale.py
index 84d106bf27..6dd27af78b 100644
--- a/modules/pmi/examples/multiscale.py
+++ b/modules/pmi/examples/multiscale.py
@@ -2,6 +2,7 @@
 """This script shows how to represent a system at multiple scales and do basic sampling.
 """
 
+from __future__ import print_function
 import IMP
 import RMF
 import IMP.atom
@@ -15,6 +16,10 @@
 import sys
 
 IMP.setup_from_argv(sys.argv, "Representation at multiple scales")
+if IMP.get_is_quick_test():
+    print("This example is too slow to test in debug mode - run without")
+    print("internal tests enabled, or without the --run-quick-test flag")
+    sys.exit(0)
 
 ###################### SYSTEM SETUP #####################
 # Read sequences etc
diff --git a/modules/pmi/pyext/src/restraints/__init__.py b/modules/pmi/pyext/src/restraints/__init__.py
index 9889e4dfd4..be016e5306 100644
--- a/modules/pmi/pyext/src/restraints/__init__.py
+++ b/modules/pmi/pyext/src/restraints/__init__.py
@@ -16,42 +16,71 @@ class RestraintBase(object):
 
     """Base class for PMI restraints, which wrap `IMP.Restraint`(s)."""
 
-    def __init__(self, m, rname=None):
+    def __init__(self, m, name=None, label=None, weight=1.):
         """Constructor.
         @param m The model object
-        @param rname The name of the primary restraint set that is wrapped.
+        @param name The name of the primary restraint set that is wrapped.
+                    This is used for outputs and particle/restraint names
+                    and should be set by the child class.
+        @param label A unique label to be used in outputs and
+                     particle/restraint names.
+        @param weight The weight to apply to all internal restraints.
         """
         self.m = m
-        self.label = None
-        self.weight = 1.
-        if rname is None:
-            rname = self.__class__.__name__
-        self.rs = IMP.RestraintSet(self.m, rname)
-        self.restraint_sets = [self.rs]
-
-    def set_weight(self, weight):
-        """Set the weight of the restraint.
-        @param weight Restraint weight
-        """
+        self.restraint_sets = []
+        self._label_is_set = False
         self.weight = weight
-        self.rs.set_weight(weight)
+        self._label = None
+        self._label_suffix = ""
+        self.set_label(label)
+
+        if not name:
+            self.name = self.__class__.__name__
+        else:
+            self.name = str(name)
+
+        self.rs = self._create_restraint_set(name=None)
 
     def set_label(self, label):
-        """Set the label used in outputs.
+        """Set the unique label used in outputs and particle/restraint names.
         @param label Label
         """
-        self.label = label
+        if self._label_is_set:
+            raise ValueError("Label has already been set.")
+        if not label:
+            self._label = ""
+            self._label_suffix = ""
+        else:
+            self._label = str(label)
+            self._label_suffix = "_" + self._label
+            self._label_is_set = True
+
+    @property
+    def label(self):
+        return self._label
+
+    def set_weight(self, weight):
+        """Set the weight to apply to all internal restraints.
+        @param weight Weight
+        """
+        self.weight = weight
+        for rs in self.restraint_sets:
+            rs.set_weight(self.weight)
 
     def add_to_model(self):
         """Add the restraint to the model."""
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
+        self._label_is_set = True
+        for rs in self.restraint_sets:
+            IMP.pmi.tools.add_restraint_to_model(self.m, rs)
 
     def evaluate(self):
         """Evaluate the score of the restraint."""
+        self._label_is_set = True
         return self.weight * self.rs.unprotected_evaluate(None)
 
     def get_restraint_set(self):
         """Get the primary restraint set."""
+        self._label_is_set = True
         return self.rs
 
     def get_restraint(self):
@@ -60,39 +89,98 @@ def get_restraint(self):
 
     def get_restraint_for_rmf(self):
         """Get the restraint for visualization in an RMF file."""
+        self._label_is_set = True
         return self.rs
 
     def get_particles_to_sample(self):
         """Get any created particles which should be sampled."""
+        self._label_is_set = True
         return {}
 
     def get_output(self):
         """Get outputs to write to stat files."""
-        self.m.update()
         output = {}
+        self.m.update()
         score = self.evaluate()
         output["_TotalScore"] = str(score)
 
-        suffix = "_Score"
-        if self.label is not None:
-            suffix += "_" + str(self.label)
-
+        suffix = "_Score" + self._label_suffix
         for rs in self.restraint_sets:
             out_name = rs.get_name() + suffix
             output[out_name] = str(
                 self.weight * rs.unprotected_evaluate(None))
+        return output
+
+    def _create_restraint_set(self, name=None):
+        """Create ``IMP.RestraintSet``."""
+        if not name:
+            name = self.name
+        else:
+            name = self.name + "_" + str(name)
+        rs = IMP.RestraintSet(self.m, name)
+        rs.set_weight(self.weight)
+        self.restraint_sets.append(rs)
+        return rs
+
+
+class _RestraintNuisanceMixin(object):
 
+    """Mix-in to add nuisance particle creation functionality to restraint.
+
+    This class must only be inherited if also inheriting
+    IMP.pmi.restraints.RestraintBase.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(_RestraintNuisanceMixin, self).__init__(*args, **kwargs)
+        self.sampled_nuisances = {}
+        self.nuisances = {}
+
+    def _create_nuisance(self, init_val, min_val, max_val, max_trans, name,
+                         is_sampled=False):
+        """Create nuisance particle.
+        @param init_val Initial value of nuisance
+        @param min_val Minimum value of nuisance
+        @param max_val Maximum value of nuisance
+        @param max_trans Maximum move to apply to nuisance
+        @param is_sampled Nuisance is a sampled particle
+        \see IMP.pmi.tools.SetupNuisance
+        """
+        nuis = IMP.pmi.tools.SetupNuisance(
+            self.m, init_val, min_val, max_val,
+            isoptimized=is_sampled).get_particle()
+        nuis_name = self.name + "_" + name
+        nuis.set_name(nuis_name)
+        self.nuisances[nuis_name] = nuis
+        if is_sampled:
+            self.sampled_nuisances[nuis_name] = (nuis, max_trans)
+        return nuis
+
+    def get_particles_to_sample(self):
+        """Get any created particles which should be sampled."""
+        ps = super(_RestraintNuisanceMixin, self).get_particles_to_sample()
+        for name, (nuis, max_trans) in self.sampled_nuisances.iteritems():
+            ps["Nuisances_" + name + self._label_suffix] = ([nuis], max_trans)
+        return ps
+
+    def get_output(self):
+        """Get outputs to write to stat files."""
+        output = super(_RestraintNuisanceMixin, self).get_output()
+        for nuis_name, nuis in self.nuisances.iteritems():
+            output[nuis_name + self._label_suffix] = str(nuis.get_scale())
         return output
 
 
 class _NuisancesBase(object):
-    ''' This base class is used to provide nuisance setup and interface
-    for the ISD cross-link restraints '''
-    sigma_dictionary={}
-    psi_dictionary={}
+
+    """This base class is used to provide nuisance setup and interface
+    for the ISD cross-link restraints"""
+
+    sigma_dictionary = {}
+    psi_dictionary = {}
 
     def create_length(self):
-        ''' a nuisance on the length of the cross-link '''
+        """Create a nuisance on the length of the cross-link."""
         lengthinit = 10.0
         self.lengthissampled = True
         lengthminnuis = 0.0000001
@@ -101,9 +189,9 @@ def create_length(self):
         lengthmax = 30.0
         lengthtrans = 0.2
         length = IMP.pmi.tools.SetupNuisance(self.m, lengthinit,
-                                                    lengthminnuis,
-                                                    lengthmaxnuis,
-                                                    lengthissampled).get_particle()
+                                             lengthminnuis, lengthmaxnuis,
+                                             self.lengthissampled
+                                             ).get_particle()
         self.rslen.add_restraint(
             IMP.isd.UniformPrior(
                 self.m,
@@ -113,8 +201,8 @@ def create_length(self):
                 lengthmin))
 
     def create_sigma(self, resolution):
-        ''' a nuisance on the structural uncertainty '''
-        if isinstance(resolution,str):
+        """Create a nuisance on the structural uncertainty."""
+        if isinstance(resolution, str):
             sigmainit = 2.0
         else:
             sigmainit = resolution + 2.0
@@ -124,8 +212,9 @@ def create_sigma(self, resolution):
         sigmamin = 0.01
         sigmamax = 100.0
         sigmatrans = 0.5
-        sigma = IMP.pmi.tools.SetupNuisance(self.m, sigmainit,
-                                                 sigmaminnuis, sigmamaxnuis, self.sigmaissampled).get_particle()
+        sigma = IMP.pmi.tools.SetupNuisance(self.m, sigmainit, sigmaminnuis,
+                                            sigmamaxnuis, self.sigmaissampled
+                                            ).get_particle()
         self.sigma_dictionary[resolution] = (
             sigma,
             sigmatrans,
@@ -140,13 +229,14 @@ def create_sigma(self, resolution):
         # self.rssig.add_restraint(IMP.isd.JeffreysRestraint(self.sigma))
 
     def get_sigma(self, resolution):
-        if not resolution in self.sigma_dictionary:
+        """Get the nuisance on structural uncertainty."""
+        if resolution not in self.sigma_dictionary:
             self.create_sigma(resolution)
         return self.sigma_dictionary[resolution]
 
     def create_psi(self, value):
-        ''' a nuisance on the inconsistency '''
-        if isinstance(value,str):
+        """Create a nuisance on the inconsistency."""
+        if isinstance(value, str):
             psiinit = 0.5
         else:
             psiinit = value
@@ -157,8 +247,8 @@ def create_psi(self, value):
         psimax = 0.49
         psitrans = 0.1
         psi = IMP.pmi.tools.SetupNuisance(self.m, psiinit,
-                                               psiminnuis, psimaxnuis,
-                                               self.psiissampled).get_particle()
+                                          psiminnuis, psimaxnuis,
+                                          self.psiissampled).get_particle()
         self.psi_dictionary[value] = (
             psi,
             psitrans,
@@ -173,6 +263,7 @@ def create_psi(self, value):
         self.rspsi.add_restraint(IMP.isd.JeffreysRestraint(self.m, psi))
 
     def get_psi(self, value):
-        if not value in self.psi_dictionary:
+        """Get the nuisance on the inconsistency."""
+        if value not in self.psi_dictionary:
             self.create_psi(value)
         return self.psi_dictionary[value]
diff --git a/modules/pmi/pyext/src/restraints/basic.py b/modules/pmi/pyext/src/restraints/basic.py
index 7f15a3e1d5..bc6930d13d 100644
--- a/modules/pmi/pyext/src/restraints/basic.py
+++ b/modules/pmi/pyext/src/restraints/basic.py
@@ -9,8 +9,12 @@
 import IMP.atom
 import IMP.container
 import IMP.pmi.tools
+import IMP.pmi.restraints
 
-class ExternalBarrier(object):
+
+class ExternalBarrier(IMP.pmi.restraints.RestraintBase):
+
+    """Restraint to keep all structures inside sphere."""
 
     def __init__(self,
                  representation=None,
@@ -18,40 +22,46 @@ def __init__(self,
                  hierarchies=None,
                  resolution=10,
                  weight=1.0,
-                 center=None):
-        """Setup external barrier to keep all your structures inside sphere
+                 center=None,
+                 label=None):
+        """Setup external barrier restraint.
         @param representation DEPRECATED
-        @param center - Center of the external barrier restraint (IMP.algebra.Vector3D object)
         @param radius Size of external barrier
-        @param hierarchies Can be one of the following inputs:
-               IMP Hierarchy, PMI System/State/Molecule/TempResidue, or a list/set of them
+        @param hierarchies Can be one of the following inputs: IMP Hierarchy,
+               PMI System/State/Molecule/TempResidue, or a list/set of them
         @param resolution Select which resolutions to act upon
+        @param weight Weight of restraint
+        @param center Center of the external barrier restraint
+               (IMP.algebra.Vector3D object)
+        @param label A unique label to be used in outputs and
+                     particle/restraint names.
         """
-        self.radius = radius
-        self.label = "None"
-        self.weight = weight
-
         if representation:
-            self.m = representation.prot.get_model()
+            m = representation.prot.get_model()
             particles = IMP.pmi.tools.select(
                 representation,
                 resolution=resolution,
                 hierarchies=hierarchies)
         elif hierarchies:
-            hiers = IMP.pmi.tools.input_adaptor(hierarchies,resolution,flatten=True)
-            self.m = hiers[0].get_model()
+            hiers = IMP.pmi.tools.input_adaptor(hierarchies, resolution,
+                                                flatten=True)
+            m = hiers[0].get_model()
             particles = [h.get_particle() for h in hiers]
         else:
-            raise Exception("ExternalBarrier: must pass representation or hierarchies")
+            raise Exception("%s: must pass representation or hierarchies" % (
+                self.name))
 
-        self.rs = IMP.RestraintSet(self.m, 'barrier')
+        super(ExternalBarrier, self).__init__(m, label=label, weight=weight)
+        self.radius = radius
 
         if center is None:
             c3 = IMP.algebra.Vector3D(0, 0, 0)
         elif type(center) is IMP.algebra.Vector3D:
             c3 = center
         else:
-            raise Exception("ExternalBarrier: @param center must be an algebra::Vector3D object")
+            raise Exception(
+                "%s: @param center must be an IMP.algebra.Vector3D object" % (
+                    self.name))
 
         ub3 = IMP.core.HarmonicUpperBound(radius, 10.0)
         ss3 = IMP.core.DistanceToSingletonScore(ub3, c3)
@@ -60,35 +70,12 @@ def __init__(self,
         lsc.add(particles)
         r3 = IMP.container.SingletonsRestraint(ss3, lsc)
         self.rs.add_restraint(r3)
-        self.set_weight(self.weight)
-
-    def set_label(self, label):
-        self.label = label
-
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-
-    def get_restraint(self):
-        return self.rs
-
-    def get_output(self):
-        self.m.update()
-        output = {}
-        score = self.evaluate()
-        output["_TotalScore"] = str(score)
-        output["ExternalBarrier_" + self.label] = str(score)
-        return output
 
-    def set_weight(self, weight):
-        self.weight = weight
-        self.rs.set_weight(weight)
 
-    def evaluate(self):
-        return self.weight * self.rs.unprotected_evaluate(None)
+class DistanceRestraint(IMP.pmi.restraints.RestraintBase):
 
-
-class DistanceRestraint(object):
     """A simple distance restraint"""
+
     def __init__(self,
                  representation=None,
                  tuple_selection1=None,
@@ -97,27 +84,34 @@ def __init__(self,
                  distancemax=100,
                  resolution=1.0,
                  kappa=1.0,
-                 root_hier = None):
+                 root_hier=None,
+                 label=None,
+                 weight=1.):
         """Setup distance restraint.
         @param representation DEPRECATED
-        @param tuple_selection1 (resnum,resnum,molecule name, copy number (=0))
-        @param tuple_selection2 (resnum,resnum,molecule name, copy number (=0))
+        @param tuple_selection1 (resnum, resnum, molecule name, copy
+               number (=0))
+        @param tuple_selection2 (resnum, resnum, molecule name, copy
+               number (=0))
         @param distancemin The minimum dist
         @param distancemax The maximum dist
         @param resolution For selecting particles
         @param kappa The harmonic parameter
-        @param root_hier The hierarchy to select from (use this instead of representation)
-        \note Pass the same resnum twice to each tuple_selection. Optionally add a copy number (PMI2 only)
+        @param root_hier The hierarchy to select from (use this instead of
+               representation)
+        @param label A unique label to be used in outputs and
+                     particle/restraint names
+        @param weight Weight of restraint
+        \note Pass the same resnum twice to each tuple_selection. Optionally
+              add a copy number (PMI2 only)
         """
-        self.weight=1.0
-        self.label="None"
         if tuple_selection1 is None or tuple_selection2 is None:
             raise Exception("You must pass tuple_selection1/2")
         ts1 = IMP.core.HarmonicUpperBound(distancemax, kappa)
         ts2 = IMP.core.HarmonicLowerBound(distancemin, kappa)
 
         if representation and not root_hier:
-            self.m = representation.prot.get_model()
+            m = representation.prot.get_model()
             particles1 = IMP.pmi.tools.select(representation,
                                               resolution=resolution,
                                               name=tuple_selection1[2],
@@ -127,12 +121,12 @@ def __init__(self,
                                               name=tuple_selection2[2],
                                               residue=tuple_selection2[0])
         elif root_hier and not representation:
-            self.m = root_hier.get_model()
+            m = root_hier.get_model()
             copy_num1 = 0
-            if len(tuple_selection1)>3:
+            if len(tuple_selection1) > 3:
                 copy_num1 = tuple_selection1[3]
             copy_num2 = 0
-            if len(tuple_selection2)>3:
+            if len(tuple_selection2) > 3:
                 copy_num2 = tuple_selection2[3]
 
             sel1 = IMP.atom.Selection(root_hier,
@@ -150,10 +144,12 @@ def __init__(self,
         else:
             raise Exception("Pass representation or root_hier, not both")
 
-        self.rs = IMP.RestraintSet(self.m, 'distance')
+        super(DistanceRestraint, self).__init__(m, label=label, weight=weight)
+        print(self.name)
 
         print("Created distance restraint between "
-              "%s and %s" % (particles1[0].get_name(),particles2[0].get_name()))
+              "%s and %s" % (particles1[0].get_name(),
+                             particles2[0].get_name()))
 
         if len(particles1) > 1 or len(particles2) > 1:
             raise ValueError("more than one particle selected")
@@ -167,33 +163,6 @@ def __init__(self,
                                        particles1[0],
                                        particles2[0]))
 
-    def set_weight(self,weight):
-        self.weight = weight
-        self.rs.set_weight(weight)
-
-    def set_label(self, label):
-        self.label = label
-
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-
-    def get_restraint(self):
-        return self.rs
-
-    def get_restraint_for_rmf(self):
-        return self.rs
-
-    def get_output(self):
-        self.m.update()
-        output = {}
-        score = self.weight * self.rs.unprotected_evaluate(None)
-        output["_TotalScore"] = str(score)
-        output["DistanceRestraint_" + self.label] = str(score)
-        return output
-
-    def evaluate(self):
-        return self.weight * self.rs.unprotected_evaluate(None)
-
 
 class TorqueRestraint(IMP.Restraint):
     import math
@@ -364,8 +333,10 @@ def do_get_inputs(self):
         return self.particle_list
 
 
-class DistanceToPointRestraint(object):
-    """DistanceToPointRestraint for anchoring a particle to a specific coordinate"""
+class DistanceToPointRestraint(IMP.pmi.restraints.RestraintBase):
+
+    """Restraint for anchoring a particle to a specific coordinate."""
+
     def __init__(self,
                  representation=None,
                  tuple_selection=None,
@@ -374,33 +345,38 @@ def __init__(self,
                  kappa=10.0,
                  resolution=1.0,
                  weight=1.0,
-                 root_hier = None):
+                 root_hier=None,
+                 label=None):
         """Setup distance restraint.
         @param representation DEPRECATED
-        @param tuple_selection (resnum,resnum,molecule name, copy number (=0))
-        @param anchor_point - Center of the DistanceToPointRestraint (IMP.algebra.Vector3D object)
-        @param radius Size of the tolerance length in DistanceToPointRestraint
+        @param tuple_selection (resnum, resnum, molecule name,
+               copy number (=0))
+        @param anchor_point Point to which to restrain particle
+               (IMP.algebra.Vector3D object)
+        @param radius Size of the tolerance length
+        @param kappa The harmonic parameter
         @param resolution For selecting a particle
-        @param root_hier The hierarchy to select from (use this instead of representation)
-        \note Pass the same resnum twice to each tuple_selection. Optionally add a copy number (PMI2 only)
+        @param weight Weight of restraint
+        @param root_hier The hierarchy to select from (use this instead of
+               representation)
+        @param label A unique label to be used in outputs and
+                     particle/restraint names
+        \note Pass the same resnum twice to each tuple_selection. Optionally
+              add a copy number (PMI2 only)
         """
-        self.radius = radius
-        self.label = "None"
-        self.weight = weight
-
         if tuple_selection is None:
             raise Exception("You must pass a tuple_selection")
 
         if representation and not root_hier:
-            self.m = representation.prot.get_model()
+            m = representation.prot.get_model()
             ps = IMP.pmi.tools.select(representation,
-                                              resolution=resolution,
-                                              name=tuple_selection[2],
-                                              residue=tuple_selection[0])
+                                      resolution=resolution,
+                                      name=tuple_selection[2],
+                                      residue=tuple_selection[0])
         elif root_hier and not representation:
-            self.m = root_hier.get_model()
+            m = root_hier.get_model()
             copy_num1 = 0
-            if len(tuple_selection)>3:
+            if len(tuple_selection) > 3:
                 copy_num1 = tuple_selection[3]
 
             sel1 = IMP.atom.Selection(root_hier,
@@ -410,18 +386,25 @@ def __init__(self,
                                       copy_index=copy_num1)
             ps = sel1.get_selected_particles()
         else:
-            raise Exception("DistanceToPointRestraint: Pass representation or root_hier, not both")
+            raise Exception("%s: Pass representation or root_hier, not both" %
+                            self.name)
         if len(ps) > 1:
-            raise ValueError("DistanceToPointRestraint: more than one particle selected")
+            raise ValueError("%s: more than one particle selected" %
+                             self.name)
+
+        super(DistanceToPointRestraint, self).__init__(m, label=label,
+                                                       weight=weight)
+        self.radius = radius
 
-        self.rs = IMP.RestraintSet(self.m, 'distance_to_point')
         ub3 = IMP.core.HarmonicUpperBound(self.radius, kappa)
         if anchor_point is None:
             c3 = IMP.algebra.Vector3D(0, 0, 0)
         elif type(anchor_point) is IMP.algebra.Vector3D:
             c3 = anchor_point
         else:
-            raise Exception("DistanceToPointRestraint: @param anchor_point must be an algebra::Vector3D object")
+            raise Exception(
+                "%s: @param anchor_point must be an algebra.Vector3D object" %
+                self.name)
         ss3 = IMP.core.DistanceToSingletonScore(ub3, c3)
 
         lsc = IMP.container.ListSingletonContainer(self.m)
@@ -429,34 +412,6 @@ def __init__(self,
 
         r3 = IMP.container.SingletonsRestraint(ss3, lsc)
         self.rs.add_restraint(r3)
-        self.set_weight(self.weight)
-
-        print("\nDistanceToPointRestraint: Created distance_to_point_restraint between "
-              "%s and %s" % (ps[0].get_name(), c3))
-
-    def set_weight(self,weight):
-        self.weight = weight
-        self.rs.set_weight(weight)
-
-    def set_label(self, label):
-        self.label = label
-
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-
-    def get_restraint(self):
-        return self.rs
-
-    def get_restraint_for_rmf(self):
-        return self.rs
-
-    def get_output(self):
-        self.m.update()
-        output = {}
-        score = self.evaluate()
-        output["_TotalScore"] = str(score)
-        output["DistanceToPointRestraint_" + self.label] = str(score)
-        return output
 
-    def evaluate(self):
-        return self.weight * self.rs.unprotected_evaluate(None)
+        print("\n%s: Created distance_to_point_restraint between "
+              "%s and %s" % (self.name, ps[0].get_name(), c3))
diff --git a/modules/pmi/pyext/src/restraints/crosslinking.py b/modules/pmi/pyext/src/restraints/crosslinking.py
index 5902a5a573..80cd904020 100644
--- a/modules/pmi/pyext/src/restraints/crosslinking.py
+++ b/modules/pmi/pyext/src/restraints/crosslinking.py
@@ -13,13 +13,14 @@
 import IMP.pmi.metadata
 import IMP.pmi.output
 import IMP.pmi.io.crosslink
+import IMP.pmi.restraints
 from math import log
 from collections import defaultdict
 import itertools
 import operator
 import os
 
-class CrossLinkingMassSpectrometryRestraint(object):
+class CrossLinkingMassSpectrometryRestraint(IMP.pmi.restraints.RestraintBase):
     """Setup cross-link distance restraints from mass spectrometry data.
     The noise in the data and the structural uncertainty of cross-linked amino-acids
     is inferred using Bayes theory of probability
@@ -31,9 +32,10 @@ def __init__(self, representation=None,
                  length=10.0,
                  resolution=None,
                  slope=0.02,
-                 label="None",
+                 label=None,
                  filelabel="None",
-                 attributes_for_label=None):
+                 attributes_for_label=None,
+                 weight=1.):
         """Constructor.
         @param representation DEPRECATED The IMP.pmi.representation.Representation
                 object that contain the molecular system
@@ -51,6 +53,7 @@ def __init__(self, representation=None,
         @param filelabel automatically generated file containing missing/included/excluded
                 cross-links will be labeled using this text
         @param attributes_for_label
+        @param weight Weight of restraint
         """
 
         use_pmi2 = True
@@ -60,12 +63,15 @@ def __init__(self, representation=None,
                 representations = [representation]
             else:
                 representations = representation
-            self.m = representations[0].prot.get_model()
+            m = representations[0].prot.get_model()
         elif root_hier is not None:
-            self.m = root_hier.get_model()
+            m = root_hier.get_model()
         else:
             raise Exception("You must pass either representation or root_hier")
 
+        super(CrossLinkingMassSpectrometryRestraint, self).__init__(
+            m, weight=weight, label=label)
+
         if CrossLinkDataBase is None:
             raise Exception("You must pass a CrossLinkDataBase")
         if not isinstance(CrossLinkDataBase,IMP.pmi.io.crosslink.CrossLinkDataBase):
@@ -79,18 +85,16 @@ def __init__(self, representation=None,
         exdb = open("excluded." + filelabel + ".xl.db", "w")
         midb = open("missing." + filelabel + ".xl.db", "w")
 
-
-        self.rs = IMP.RestraintSet(self.m, 'likelihood')
-        self.rspsi = IMP.RestraintSet(self.m, 'prior_psi')
-        self.rssig = IMP.RestraintSet(self.m, 'prior_sigmas')
-        self.rslin = IMP.RestraintSet(self.m, 'linear_dummy_restraints')
+        self.rs.set_name(self.rs.get_name() + "_Data")
+        self.rspsi = self._create_restraint_set("PriorPsi")
+        self.rssig = self._create_restraint_set("PriorSig")
+        self.rslin = self._create_restraint_set("Linear")
 
         # dummy linear restraint used for Chimera display
         self.linear = IMP.core.Linear(0, 0.0)
         self.linear.set_slope(0.0)
         dps2 = IMP.core.DistancePairScore(self.linear)
 
-        self.label = label
         self.psi_is_sampled = True
         self.sigma_is_sampled = True
         self.psi_dictionary={}
@@ -291,13 +295,6 @@ def __init__(self, representation=None,
         lw = IMP.isd.LogWrapper(restraints,1.0)
         self.rs.add_restraint(lw)
 
-    def add_to_model(self):
-        """ Add the restraint to the model so that it is evaluated """
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rspsi)
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rssig)
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rslin)
-
     def get_hierarchies(self):
         """ get the hierarchy """
         return self.prot
@@ -306,14 +303,6 @@ def get_restraint_sets(self):
         """ get the restraint set """
         return self.rs
 
-    def get_restraint(self):
-        """ get the restraint set  (redundant with get_restraint_sets)"""
-        return self.rs
-
-    def get_restraint_for_rmf(self):
-        """ get the dummy restraints to be displayed in the rmf file """
-        return self.rslin
-
     def get_restraints(self):
         """ get the restraints in a list """
         rlist = []
@@ -321,6 +310,10 @@ def get_restraints(self):
             rlist.append(IMP.core.PairRestraint.get_from(r))
         return rlist
 
+    def get_restraint_for_rmf(self):
+        """ get the dummy restraints to be displayed in the rmf file """
+        return self.rslin
+
     def get_particle_pairs(self):
         """ Get a list of tuples containing the particle pairs """
         ppairs = []
@@ -401,24 +394,10 @@ def create_psi(self, name):
         self.rspsi.add_restraint(IMP.isd.JeffreysRestraint(self.m, psi))
         return psi
 
-    def set_label(self, s):
-        """ Set the restraint output label """
-        self.label=s
-
     def get_output(self):
         """ Get the output of the restraint to be used by the IMP.pmi.output object"""
-        self.m.update()
+        output = super(CrossLinkingMassSpectrometryRestraint, self).get_output()
 
-        output = {}
-        score = self.rs.unprotected_evaluate(None)
-        output["_TotalScore"] = str(score)
-        output["CrossLinkingMassSpectrometryRestraint_Data_Score_" + self.label] = str(score)
-        output["CrossLinkingMassSpectrometryRestraint_PriorSig_Score_" +
-               self.label] = self.rssig.unprotected_evaluate(None)
-        output["CrossLinkingMassSpectrometryRestraint_PriorPsi_Score_" +
-                   self.label] = self.rspsi.unprotected_evaluate(None)
-        output["CrossLinkingMassSpectrometryRestraint_Linear_Score_" +
-               self.label] = self.rslin.unprotected_evaluate(None)
         for xl in self.xl_list:
 
             xl_label=xl["ShortLabel"]
@@ -436,11 +415,13 @@ def get_output(self):
 
         for psiname in self.psi_dictionary:
             output["CrossLinkingMassSpectrometryRestraint_Psi_" +
-                    str(psiname) + "_" + self.label] = str(self.psi_dictionary[psiname][0].get_scale())
+                    str(psiname) + self._label_suffix] = str(
+                        self.psi_dictionary[psiname][0].get_scale())
 
         for sigmaname in self.sigma_dictionary:
             output["CrossLinkingMassSpectrometryRestraint_Sigma_" +
-                   str(sigmaname) + "_" + self.label] = str(self.sigma_dictionary[sigmaname][0].get_scale())
+                   str(sigmaname) + self._label_suffix] = str(
+                    self.sigma_dictionary[sigmaname][0].get_scale())
 
 
         return output
@@ -450,20 +431,21 @@ def get_particles_to_sample(self):
         ps = {}
         if self.sigma_is_sampled:
             for sigmaname in self.sigma_dictionary:
-                ps["Nuisances_CrossLinkingMassSpectrometryRestraint_Sigma_" + str(sigmaname) + "_" + self.label] =\
+                ps["Nuisances_CrossLinkingMassSpectrometryRestraint_Sigma_" +
+                   str(sigmaname) + self._label_suffix] =\
                     ([self.sigma_dictionary[sigmaname][0]],
                      self.sigma_dictionary[sigmaname][1])
 
         if self.psi_is_sampled:
             for psiname in self.psi_dictionary:
                 ps["Nuisances_CrossLinkingMassSpectrometryRestraint_Psi_" +
-                    str(psiname) + "_" + self.label] =\
+                    str(psiname) + self._label_suffix] =\
                    ([self.psi_dictionary[psiname][0]], self.psi_dictionary[psiname][1])
 
         return ps
 
 
-class AtomicCrossLinkMSRestraint(object):
+class AtomicCrossLinkMSRestraint(IMP.pmi.restraints.RestraintBase):
     """Setup cross-link distance restraints at atomic level
     The "atomic" aspect is that it models the particle uncertainty with a Gaussian
     The noise in the data and the structural uncertainty of cross-linked amino-acids
@@ -477,12 +459,13 @@ def __init__(self,
                  length=10.0,
                  slope=0.01,
                  nstates=None,
-                 label='',
+                 label=None,
                  nuisances_are_optimized=True,
                  sigma_init=5.0,
                  psi_init = 0.01,
                  one_psi=True,
-                 filelabel=None):
+                 filelabel=None,
+                 weight=1.):
         """Constructor.
         Automatically creates one "sigma" per crosslinked residue and one "psis" per pair.
         Other nuisance options are available.
@@ -500,14 +483,17 @@ def __init__(self,
         @param one_psi    Use a single psi for all restraints (if False, creates one per XL)
         @param filelabel automatically generated file containing missing/included/excluded
                 cross-links will be labeled using this text
+        @param weight Weight of restraint
+
         """
 
         # basic params
         self.root = root_hier
-        self.mdl = self.root.get_model()
+        rname = "AtomicXLRestraint"
+        super(AtomicCrossLinkMSRestraint, self).__init__(
+            self.root.get_model(), name="AtomicXLRestraint", label=label,
+            weight=weight)
         self.xldb = xldb
-        self.weight = 1.0
-        self.label = label
         self.length = length
         self.sigma_is_sampled = nuisances_are_optimized
         self.psi_is_sampled = nuisances_are_optimized
@@ -521,11 +507,9 @@ def __init__(self,
         elif nstates!=len(IMP.atom.get_by_type(self.root,IMP.atom.STATE_TYPE)):
             print("Warning: nstates is not the same as the number of states in root")
 
-        self.rs = IMP.RestraintSet(self.mdl, 'likelihood')
-        self.rs_psi = IMP.RestraintSet(self.mdl, 'prior_psi')
-        self.rs_sig = IMP.RestraintSet(self.mdl, 'prior_sigmas')
-        self.rs_lin = IMP.RestraintSet(self.mdl, 'linear_dummy_restraints')
-
+        self.rs_psi = self._create_restraint_set("psi")
+        self.rs_sig = self._create_restraint_set("sigma")
+        self.rs_lin = self._create_restraint_set("linear")
 
         self.psi_dictionary = {}
         self.sigma_dictionary = {}
@@ -558,9 +542,9 @@ def __init__(self,
 
         # Will setup two sigmas based on promiscuity of the residue
         sig_threshold=4
-        self.sig_low = setup_nuisance(self.mdl,self.rs_nuis,init_val=sigma_init,min_val=1.0,
+        self.sig_low = setup_nuisance(self.m,self.rs_nuis,init_val=sigma_init,min_val=1.0,
                                       max_val=100.0,is_opt=self.nuis_opt)
-        self.sig_high = setup_nuisance(self.mdl,self.rs_nuis,init_val=sigma_init,min_val=1.0,
+        self.sig_high = setup_nuisance(self.m,self.rs_nuis,init_val=sigma_init,min_val=1.0,
                                        max_val=100.0,is_opt=self.nuis_opt)
         '''
         self._create_sigma('sigma',sigma_init)
@@ -578,7 +562,7 @@ def __init__(self,
                 psip = self.psi_dictionary['psi'][0].get_particle_index()
             else:
                 psip = self.psi_dictionary[unique_id][0].get_particle_index()
-            r = IMP.isd.AtomicCrossLinkMSRestraint(self.mdl,
+            r = IMP.isd.AtomicCrossLinkMSRestraint(self.m,
                                                    self.length,
                                                    psip,
                                                    slope,
@@ -648,26 +632,15 @@ def __init__(self,
         if len(xlrs)==0:
             raise Exception("You didn't create any XL restraints")
         print('created',len(xlrs),'XL restraints')
-        self.rs=IMP.isd.LogWrapper(xlrs,self.weight)
-
-    def set_weight(self,weight):
-        self.weight = weight
-        self.rs.set_weight(weight)
-
-    def set_label(self, label):
-        self.label = label
-
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.mdl, self.rs)
-        IMP.pmi.tools.add_restraint_to_model(self.mdl, self.rs_sig)
-        IMP.pmi.tools.add_restraint_to_model(self.mdl, self.rs_psi)
+        rname = self.rs.get_name()
+        self.rs=IMP.isd.LogWrapper(xlrs, self.weight)
+        self.rs.set_name(rname)
+        self.rs.set_weight(self.weight)
+        self.restraint_sets = [self.rs] + self.restraint_sets[1:]
 
     def get_hierarchy(self):
         return self.prot
 
-    def get_restraint_set(self):
-        return self.rs
-
     def _create_sigma(self, name,sigmainit):
         """ This is called internally. Creates a nuisance
         on the structural uncertainty """
@@ -679,7 +652,7 @@ def _create_sigma(self, name,sigmainit):
         sigmamin = 0.01
         sigmamax = 100.0
         sigmatrans = 0.5
-        sigma = IMP.pmi.tools.SetupNuisance(self.mdl,
+        sigma = IMP.pmi.tools.SetupNuisance(self.m,
                                             sigmainit,
                                             sigmaminnuis,
                                             sigmamaxnuis,
@@ -690,7 +663,7 @@ def _create_sigma(self, name,sigmainit):
             self.sigma_is_sampled)
         self.rs_sig.add_restraint(
             IMP.isd.UniformPrior(
-                self.mdl,
+                self.m,
                 sigma,
                 1000000000.0,
                 sigmamax,
@@ -708,7 +681,7 @@ def _create_psi(self, name,psiinit):
         psimin = 0.01
         psimax = 0.49
         psitrans = 0.1
-        psi = IMP.pmi.tools.SetupNuisance(self.mdl,
+        psi = IMP.pmi.tools.SetupNuisance(self.m,
                                           psiinit,
                                           psiminnuis,
                                           psimaxnuis,
@@ -720,13 +693,13 @@ def _create_psi(self, name,psiinit):
 
         self.rs_psi.add_restraint(
             IMP.isd.UniformPrior(
-                self.mdl,
+                self.m,
                 psi,
                 1000000000.0,
                 psimax,
                 psimin))
 
-        self.rs_psi.add_restraint(IMP.isd.JeffreysRestraint(self.mdl, psi))
+        self.rs_psi.add_restraint(IMP.isd.JeffreysRestraint(self.m, psi))
         return psi
 
     def create_restraints_for_rmf(self):
@@ -747,7 +720,7 @@ def get_restraint_for_rmf(self):
             rs = IMP.RestraintSet(dummy_mdl, 'atomic_xl_'+str(nxl))
             for ncontr in range(xl.get_number_of_contributions()):
                 ps=xl.get_contribution(ncontr)
-                dr = IMP.core.PairRestraint(hps,[self.mdl.get_particle(p) for p in ps],
+                dr = IMP.core.PairRestraint(hps,[self.m.get_particle(p) for p in ps],
                                             'xl%i_contr%i'%(nxl,ncontr))
                 rs.add_restraint(dr)
                 dummy_rs.append(MyGetRestraint(rs))
@@ -759,13 +732,14 @@ def get_particles_to_sample(self):
         ps = {}
         if self.sigma_is_sampled:
             for sigmaname in self.sigma_dictionary:
-                ps["Nuisances_AtomicCrossLinkingMSRestraint_Sigma_" + str(sigmaname) + "_" + self.label] = \
+                ps["Nuisances_AtomicCrossLinkingMSRestraint_Sigma_" +
+                   str(sigmaname) + self._label_suffix] = \
                     ([self.sigma_dictionary[sigmaname][0]],
                      self.sigma_dictionary[sigmaname][1])
         if self.psi_is_sampled:
             for psiname in self.psi_dictionary:
                 ps["Nuisances_CrossLinkingMassSpectrometryRestraint_Psi_" +
-                    str(psiname) + "_" + self.label] =\
+                    str(psiname) + self._label_suffix] =\
                    ([self.psi_dictionary[psiname][0]], self.psi_dictionary[psiname][1])
         return ps
 
@@ -793,10 +767,10 @@ def load_nuisances_from_stat_file(self,in_fn,nframe):
         for nxl in range(self.rs.get_number_of_restraints()):
             xl=IMP.isd.AtomicCrossLinkMSRestraint.get_from(self.rs.get_restraint(nxl))
             psip = xl.get_psi()
-            IMP.isd.Scale(self.mdl,psip).set_scale(psi_val)
+            IMP.isd.Scale(self.m,psip).set_scale(psi_val)
             for contr in range(xl.get_number_of_contributions()):
                 sig1,sig2=xl.get_contribution_sigmas(contr)
-                IMP.isd.Scale(self.mdl,sig1).set_scale(sig_val)
+                IMP.isd.Scale(self.m,sig1).set_scale(sig_val)
 
         print('loaded nuisances from file')
 
@@ -877,13 +851,13 @@ def plot_violations(self,out_prefix,
                         r=0.365; g=0.933; b=0.365;
                 # now only showing if UNIQUELY PASSING in this state
                 pp = state_info[nstate][nxl]["low_pp"]
-                c1=IMP.core.XYZ(self.mdl,pp[0]).get_coordinates()
-                c2=IMP.core.XYZ(self.mdl,pp[1]).get_coordinates()
+                c1=IMP.core.XYZ(self.m,pp[0]).get_coordinates()
+                c2=IMP.core.XYZ(self.m,pp[1]).get_coordinates()
 
-                r1 = IMP.atom.get_residue(IMP.atom.Atom(self.mdl,pp[0])).get_index()
-                ch1 = IMP.atom.get_chain_id(IMP.atom.Atom(self.mdl,pp[0]))
-                r2 = IMP.atom.get_residue(IMP.atom.Atom(self.mdl,pp[0])).get_index()
-                ch2 = IMP.atom.get_chain_id(IMP.atom.Atom(self.mdl,pp[0]))
+                r1 = IMP.atom.get_residue(IMP.atom.Atom(self.m,pp[0])).get_index()
+                ch1 = IMP.atom.get_chain_id(IMP.atom.Atom(self.m,pp[0]))
+                r2 = IMP.atom.get_residue(IMP.atom.Atom(self.m,pp[0])).get_index()
+                ch2 = IMP.atom.get_chain_id(IMP.atom.Atom(self.m,pp[0]))
 
                 cmds[nstate].add((ch1,r1))
                 cmds[nstate].add((ch2,r2))
@@ -912,12 +886,12 @@ def _get_contribution_info(self,xl,ncontr,use_CA=False):
         idx1=xl.get_contribution(ncontr)[0]
         idx2=xl.get_contribution(ncontr)[1]
         if use_CA:
-            idx1 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.mdl,idx1)),
+            idx1 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.m,idx1)),
                                       atom_type=IMP.atom.AtomType("CA")).get_selected_particle_indexes()[0]
-            idx2 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.mdl,idx2)),
+            idx2 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.m,idx2)),
                                       atom_type=IMP.atom.AtomType("CA")).get_selected_particle_indexes()[0]
-        dist = IMP.algebra.get_distance(IMP.core.XYZ(self.mdl,idx1).get_coordinates(),
-                                        IMP.core.XYZ(self.mdl,idx2).get_coordinates())
+        dist = IMP.algebra.get_distance(IMP.core.XYZ(self.m,idx1).get_coordinates(),
+                                        IMP.core.XYZ(self.m,idx2).get_coordinates())
         return idx1,idx2,dist
 
     def get_best_stats(self,limit_to_state=None,limit_to_chains=None,exclude_chains='',use_CA=False):
@@ -941,21 +915,21 @@ def get_best_stats(self,limit_to_state=None,limit_to_chains=None,exclude_chains=
             for contr in range(xl.get_number_of_contributions()):
                 pp = xl.get_contribution(contr)
                 if use_CA:
-                    idx1 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.mdl,pp[0])),
+                    idx1 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.m,pp[0])),
                                               atom_type=IMP.atom.AtomType("CA")).get_selected_particle_indexes()[0]
-                    idx2 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.mdl,pp[1])),
+                    idx2 = IMP.atom.Selection(IMP.atom.get_residue(IMP.atom.Atom(self.m,pp[1])),
                                               atom_type=IMP.atom.AtomType("CA")).get_selected_particle_indexes()[0]
                     pp = [idx1,idx2]
                 if limit_to_state is not None:
-                    nstate = IMP.atom.get_state_index(IMP.atom.Atom(self.mdl,pp[0]))
+                    nstate = IMP.atom.get_state_index(IMP.atom.Atom(self.m,pp[0]))
                     if nstate!=limit_to_state:
                         continue
                     state_contrs.append(contr)
-                dist = IMP.core.get_distance(IMP.core.XYZ(self.mdl,pp[0]),
-                                             IMP.core.XYZ(self.mdl,pp[1]))
+                dist = IMP.core.get_distance(IMP.core.XYZ(self.m,pp[0]),
+                                             IMP.core.XYZ(self.m,pp[1]))
                 if limit_to_chains is not None:
-                    c1 = IMP.atom.get_chain_id(IMP.atom.Atom(self.mdl,pp[0]))
-                    c2 = IMP.atom.get_chain_id(IMP.atom.Atom(self.mdl,pp[1]))
+                    c1 = IMP.atom.get_chain_id(IMP.atom.Atom(self.m,pp[0]))
+                    c2 = IMP.atom.get_chain_id(IMP.atom.Atom(self.m,pp[1]))
                     if (c1 in limit_to_chains or c2 in limit_to_chains) and (
                             c1 not in exclude_chains and c2 not in exclude_chains):
                         if dist<low_dist_lim:
@@ -976,7 +950,7 @@ def get_best_stats(self,limit_to_state=None,limit_to_chains=None,exclude_chains=
 
             this_info["low_dist"] = low_dist
             if not self.one_psi:
-                pval = IMP.isd.Scale(self.mdl,xl.get_psi()).get_scale()
+                pval = IMP.isd.Scale(self.m,xl.get_psi()).get_scale()
                 this_info["psi"] = pval
             ret.append(this_info)
         return ret
@@ -990,16 +964,10 @@ def print_stats(self):
 
 
     def get_output(self):
-        self.mdl.update()
-        output = {}
-        score = self.weight * self.rs.unprotected_evaluate(None)
-        output["_TotalScore"] = str(score)
-        output["AtomicXLRestraint" + self.label] = str(score)
+        output = super(AtomicCrossLinkMSRestraint, self).get_output()
 
         ### HACK to make it easier to see the few sigmas
         #output["AtomicXLRestraint_sigma"] = self.sigma.get_scale()
-        output["AtomicXLRestraint_sigma"] = self.rs_sig.unprotected_evaluate(None)
-        output["AtomicXLRestraint_psi"] = self.rs_psi.unprotected_evaluate(None)
         #if self.one_psi:
         #    output["AtomicXLRestraint_psi"] = self.psi.get_scale()
         ######
diff --git a/modules/pmi/pyext/src/restraints/parameters.py b/modules/pmi/pyext/src/restraints/parameters.py
index c085d56345..255cd52a99 100644
--- a/modules/pmi/pyext/src/restraints/parameters.py
+++ b/modules/pmi/pyext/src/restraints/parameters.py
@@ -1,69 +1,51 @@
-#!/usr/bin/env python
+"""@namespace IMP.pmi.restraints.parameters
+Restraints for parameters.
+"""
+
 import IMP
-import IMP.core
-import IMP.algebra
-import IMP.atom
-import IMP.container
 import IMP.isd
 import IMP.pmi.tools
+import IMP.pmi.restraints
+
 
-class WeightRestraint(object):
+class WeightRestraint(IMP.pmi.restraints.RestraintBase):
 
-    def __init__(self, weight, lower, upper, kappa):
+    """Wrapper for an ``IMP.isd.WeightRestraint``"""
 
-        self.weight = weight
-        self.m = self.weight.get_model()
-        self.label = "None"
-        self.rs = IMP.RestraintSet(self.m, 'weight_restraint')
+    def __init__(self, w, lower, upper, kappa, label=None, weight=1.):
+        """Create restraint on weight parameter.
+        @param w ``IMP.isd.Weight`` particle
+        @param lower Lower bound on weight restraint
+        @param upper Upper bound on weight restraint
+        @param kappa Strength of restraint
+        @param label A unique label to be used in outputs
+        @param weight The weight to apply to all internal restraints
+        """
+        self.w = w
+        m = self.w.get_model()
+        super(WeightRestraint, self).__init__(m, label=label, weight=weight)
         self.lower = lower
         self.upper = upper
         self.kappa = kappa
         self.rs.add_restraint(
             IMP.isd.WeightRestraint(
-                self.weight,
+                self.w,
                 self.lower,
                 self.upper,
                 self.kappa))
 
-    def get_restraint(self, label):
-        return self.rs
-
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-
-    def set_label(self, label):
-        self.label = label
-
-    def get_output(self):
-        self.m.update()
-        output = {}
-        score = self.rs.unprotected_evaluate(None)
-        output["_TotalScore"] = str(score)
-        output["WeightRestraint_" + self.label] = str(score)
-        return output
 
+class JeffreysPrior(IMP.pmi.restraints.RestraintBase):
 
-class JeffreysPrior(object):
+    """Wrapper for ``IMP.isd.JeffreysRestraint``"""
 
-    def __init__(self, nuisance):
-
-        self.m = nuisance.get_model()
-        self.label = "None"
-        self.rs = IMP.RestraintSet(self.m, 'jeffrey_prior')
+    def __init__(self, nuisance, label=None, weight=1.):
+        """Create Jeffreys prior.
+        @param nuisance Nuisance parameter
+        @param label A unique label to be used in outputs
+        @param weight The weight to apply to all internal restraints
+        """
+        m = nuisance.get_model()
+        super(JeffreysPrior, self).__init__(m, label=label, weight=weight)
         jp = IMP.isd.JeffreysRestraint(self.m, nuisance)
         self.rs.add_restraint(jp)
-
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-
-    def set_label(self, label):
-        self.label = label
-
-    def get_output(self):
-        output = {}
-        score = self.rs.unprotected_evaluate(None)
-        output["_TotalScore"] = str(score)
-        output["JeffreyPrior_" + self.label] = str(score)
-        return output
-
-#
diff --git a/modules/pmi/pyext/src/restraints/saxs.py b/modules/pmi/pyext/src/restraints/saxs.py
index 9b8cbb444e..fde91864e5 100644
--- a/modules/pmi/pyext/src/restraints/saxs.py
+++ b/modules/pmi/pyext/src/restraints/saxs.py
@@ -3,82 +3,80 @@
 """
 
 from __future__ import print_function
+import math
 import IMP
 import IMP.core
 import IMP.algebra
 import IMP.atom
 import IMP.container
 import IMP.pmi.tools
-
-class SAXSRestraint(object):
-    import IMP.saxs
-    import IMP.pmi.tools
-
-    def __init__(self, input_objects, saxs_datafile, weight=1.0, ff_type=IMP.saxs.HEAVY_ATOMS, label=None):
-        '''Builds a basic SAXS restraint.
-        @param input_objects - A list of hierarchies or PMI objects that the SAXS restraint will be applied to.
-                                This hierarchy MUST be atomic.  You can pass a list of CA atom particles to evaluate
-                                at residue resolution
-        @param saxs_datafile - the SAXS .dat file. 
-        @param weight - Restraint score coefficient
-        @param ff_type - the form factor to use:
-                ff_type = IMP.saxs.HEAVY_ATOMS  :  use form factors with implicit hydrogens
-                ff_type = IMP.saxs.ALL_ATOMS  :  use individual form factors for all atoms. Does not build missing hydrogens.
-                ff_type = IMP.saxs.CA_ATOMS  :  use residue based form factors centered at CA atoms
-        '''
-        
-        hiers = IMP.pmi.tools.input_adaptor(input_objects, pmi_resolution=0, flatten=True)
-        self.m = list(hiers)[0].get_model()
-        if label is None:
-            label=""
-        self.rs = IMP.RestraintSet(self.m, 'SAXSRestraint_' + label)
+import IMP.pmi.restraints
+import IMP.saxs
+
+
+class SAXSRestraint(IMP.pmi.restraints.RestraintBase):
+
+    """Basic SAXS restraint."""
+
+    def __init__(self, input_objects, saxs_datafile, weight=1.0,
+                 ff_type=IMP.saxs.HEAVY_ATOMS, label=None):
+        """Builds the restraint.
+        @param input_objects A list of hierarchies or PMI objects that the
+               SAXS restraint will be applied to. This hierarchy MUST be
+               atomic. You can pass a list of CA atom particles to evaluate
+               at residue resolution
+        @param saxs_datafile the SAXS .dat file.
+        @param weight Restraint score coefficient
+        @param ff_type the form factor to use, of the following types:
+                   - IMP.saxs.HEAVY_ATOMS: use form factors with implicit
+                     hydrogens
+                   - IMP.saxs.ALL_ATOMS: use individual form factors for all
+                     atoms. Does not build missing hydrogens.
+                   - IMP.saxs.CA_ATOMS: use residue based form factors
+                     centered at CA atoms
+        @param label Label for the restraint in outputs
+        """
+        hiers = IMP.pmi.tools.input_adaptor(input_objects, pmi_resolution=0,
+                                            flatten=True)
+        m = list(hiers)[0].get_model()
+        super(SAXSRestraint, self).__init__(m, label=label, weight=weight)
         self.profile = IMP.saxs.Profile(saxs_datafile)
-        self.weight = weight
-
-        if ff_type==IMP.saxs.CA_ATOMS:
-            self.particles = IMP.atom.Selection(hiers, atom_type=IMP.atom.AT_CA).get_selected_particles()           
-        elif ff_type==IMP.saxs.HEAVY_ATOMS:
-            self.particles = IMP.atom.Selection(hiers, resolution=0).get_selected_particles()
-        elif ff_type==IMP.saxs.ALL_ATOMS:
-            self.particles = IMP.atom.Selection(hiers, resolution=0).get_selected_particles()
+
+        if ff_type == IMP.saxs.CA_ATOMS:
+            self.particles = IMP.atom.Selection(
+                hiers, atom_type=IMP.atom.AT_CA).get_selected_particles()
+        elif ff_type == IMP.saxs.HEAVY_ATOMS:
+            self.particles = IMP.atom.Selection(
+                hiers, resolution=0).get_selected_particles()
+        elif ff_type == IMP.saxs.ALL_ATOMS:
+            self.particles = IMP.atom.Selection(
+                hiers, resolution=0).get_selected_particles()
         else:
-            raise Exception("SAXSRestraint: Must provide an IMP.saxs atom type: CA_ATOMS, HEAVY_ATOMS or ALL_ATOMS")
-        if len(self.particles)==0:
+            raise Exception("SAXSRestraint: Must provide an IMP.saxs atom "
+                            "type: CA_ATOMS, HEAVY_ATOMS or ALL_ATOMS")
+        if len(self.particles) == 0:
             raise Exception("SAXSRestraint: There are no selected particles")
 
-        self.restraint = IMP.saxs.Restraint(self.particles, self.profile, ff_type)
+        self.restraint = IMP.saxs.Restraint(self.particles, self.profile,
+                                            ff_type)
         self.rs.add_restraint(self.restraint)
 
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-
-    def evaluate(self):
-        return self.weight * self.rs.unprotected_evaluate(None)
-
-    def get_output(self):
-        self.m.update()
-        output = {}
-        score = self.evaluate()
-        output["_TotalScore"] = str(score)
 
-        return output
+class SAXSISDRestraint(IMP.pmi.restraints.RestraintBase):
 
-class SAXSISDRestraint(object):
+    """Basic SAXS restraint using ISD."""
 
-    import IMP.saxs
     import IMP.isd
     try:
         import IMP.isd2
     except:
         print("Module isd2 not installed. Cannot use SAXSISDRestraint")
-    import IMP.pmi.tools
 
     def __init__(self, representation, profile, resolution=0, weight=1,
-                 ff_type=IMP.saxs.HEAVY_ATOMS):
+                 ff_type=IMP.saxs.HEAVY_ATOMS, label=None):
 
-        self.m = representation.prot.get_model()
-        self.label = "None"
-        self.rs = IMP.RestraintSet(self.m, 'saxs')
+        m = representation.prot.get_model()
+        super(SAXSISDRestraint, self).__init__(m, label=label, weight=weight)
 
         self.taumaxtrans = 0.05
         self.prof = IMP.saxs.Profile(profile)
@@ -99,13 +97,13 @@ def __init__(self, representation, profile, resolution=0, weight=1,
         self.tau = IMP.pmi.tools.SetupNuisance(self.m, 1., 0., None, False,
                                                ).get_particle()
 
-        #c1 and c2, optimized
+        # c1 and c2, optimized
         self.c1 = IMP.pmi.tools.SetupNuisance(self.m, 1.0, 0.95, 1.05,
                                               True).get_particle()
         self.c2 = IMP.pmi.tools.SetupNuisance(self.m, 0.0, -2., 4.,
                                               True).get_particle()
 
-        #weight, optimized
+        # weight, optimized
         self.w = IMP.pmi.tools.SetupWeight(self.m).get_particle()
         IMP.isd.Weight(self.w).set_weights_are_optimized(True)
 
@@ -115,16 +113,16 @@ def __init__(self, representation, profile, resolution=0, weight=1,
 
         print("create saxs restraint")
         self.saxs = IMP.isd2.SAXSRestraint(self.prof, self.sigma, self.tau,
-                                           self.gamma, self.w, self.c1, self.c2)
+                                           self.gamma, self.w, self.c1,
+                                           self.c2)
         self.saxs.add_scatterer(self.atoms, self.cov, ff_type)
 
         self.rs.add_restraint(self.saxs)
-        self.rs.set_weight(weight)
 
         # self.saxs_stuff={'nuis':(sigma,gamma),'cov':cov,
         #        'exp':prof,'th':tmp}
 
-        self.rs2 = IMP.RestraintSet(self.m, 'jeffreys')
+        self.rs2 = self._create_restraint_set('Prior')
         # jeffreys restraints for nuisances
         j1 = IMP.isd.JeffreysRestraint(self.m, self.sigma)
         self.rs2.add_restraint(j1)
@@ -134,35 +132,25 @@ def __init__(self, representation, profile, resolution=0, weight=1,
         self.rs2.add_restraint(j3)
 
     def optimize_sigma(self):
-        """set sigma to the value that maximizes its conditional likelihood"""
-        from math import sqrt
+        """Set sigma to the value that maximizes its conditional likelihood"""
         self.m.update()
         sigma2hat = self.saxs.get_sigmasq_scale_parameter() \
             / (self.saxs.get_sigmasq_shape_parameter() + 1)
-        IMP.isd.Scale(self.sigma).set_scale(sqrt(sigma2hat))
+        IMP.isd.Scale(self.sigma).set_scale(math.sqrt(sigma2hat))
 
     def optimize_gamma(self):
-        """set gamma to the value that maximizes its conditional likelihood"""
-        from math import exp
+        """Set gamma to the value that maximizes its conditional likelihood"""
         self.m.update()
-        gammahat = exp(self.saxs.get_loggamma_variance_parameter()
-                       * self.saxs.get_loggamma_jOg_parameter())
+        gammahat = math.exp(self.saxs.get_loggamma_variance_parameter() *
+                            self.saxs.get_loggamma_jOg_parameter())
         IMP.isd.Scale(self.gamma).set_scale(gammahat)
 
-    def logspace(self, a, b, num=100):
-        """mimick numpy's logspace function"""
-        for i in range(num):
-            val = a + float(b - a) / float(num - 1) * i
-            yield 10 ** val
-
     def optimize_tau(self, ltaumin=-2, ltaumax=3, npoints=100):
-        from math import log
-        import IMP.atom
         values = []
         self.m.update()
         IMP.atom.write_pdb(self.atoms, 'tauvals.pdb')
         fl = open('tauvals.txt', 'w')
-        for tauval in self.logspace(ltaumin, ltaumax, npoints):
+        for tauval in self._logspace(ltaumin, ltaumax, npoints):
             IMP.isd.Scale(self.tau).set_scale(tauval)
             try:
                 values.append((self.m.evaluate(False), tauval))
@@ -170,10 +158,10 @@ def optimize_tau(self, ltaumin=-2, ltaumax=3, npoints=100):
                 pass
             fl.write('%G %G\n' % (values[-1][1], values[-1][0]))
         values.sort()
-        ltcenter = log(values[0][1]) / log(10)
+        ltcenter = math.log(values[0][1]) / math.log(10)
         spacing = (ltaumax - ltaumin) / float(npoints)
         values = []
-        for tauval in self.logspace(
+        for tauval in self._logspace(
             ltcenter - 2 * spacing, ltcenter + 2 * spacing,
                 npoints):
             IMP.isd.Scale(self.tau).set_scale(tauval)
@@ -182,20 +170,27 @@ def optimize_tau(self, ltaumin=-2, ltaumax=3, npoints=100):
         values.sort()
         IMP.isd.Scale(self.tau).set_scale(values[0][1])
 
+    def get_gamma_value(self):
+        """Get value of gamma."""
+        return self.gamma.get_scale()
+
+    def set_taumaxtrans(self, taumaxtrans):
+        self.taumaxtrans = taumaxtrans
+
     def draw_sigma(self):
-        """draw 1/sigma2 from gamma distribution"""
+        """Draw 1/sigma2 from gamma distribution."""
         self.m.update()
         self.saxs.draw_sigma()
 
     def draw_gamma(self):
-        """draw gamma from lognormal distribution"""
+        """Draw gamma from lognormal distribution."""
         self.m.update()
         self.saxs.draw_gamma()
 
     def update_covariance_matrix(self):
         c1 = IMP.isd.Nuisance(self.c1).get_nuisance()
         c2 = IMP.isd.Nuisance(self.c2).get_nuisance()
-        #tau = IMP.isd.Nuisance(self.tau).get_nuisance()
+        # tau = IMP.isd.Nuisance(self.tau).get_nuisance()
         tau = 1.0
         self.cov = IMP.isd2.compute_relative_covariance(self.atoms, c1, c2,
                                                         tau, self.prof)
@@ -211,38 +206,19 @@ def write_covariance_matrix(self, fname):
                 fl.write('%G ' % i)
             fl.write('\n')
 
-    def get_gamma_value(self):
-        return self.gamma.get_scale()
-
-    def set_label(self, label):
-        self.label = label
-
-    def add_to_model(self):
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs)
-        IMP.pmi.tools.add_restraint_to_model(self.m, self.rs2)
-
-    def set_taumaxtrans(self, taumaxtrans):
-        self.taumaxtrans = taumaxtrans
-
-    def get_particles_to_sample(self):
-        ps = {}
-        # ps["Nuisances_SAXSISDRestraint_Tau_" +
-        #    self.label] = ([self.tau], self.taumaxtrans)
-        return ps
-
     def get_output(self):
-        self.m.update()
-        output = {}
-        score = self.rs.unprotected_evaluate(None)
-        score2 = self.rs2.unprotected_evaluate(None)
-        output["_TotalScore"] = str(score + score2)
-
-        output["SAXSISDRestraint_Likelihood_" + self.label] = str(score)
-        output["SAXSISDRestraint_Prior_" + self.label] = str(score2)
-        output["SAXSISDRestraint_Sigma_" +
-               self.label] = str(self.sigma.get_scale())
-        output["SAXSISDRestraint_Tau_" +
-               self.label] = str(self.tau.get_scale())
-        output["SAXSISDRestraint_Gamma_" +
-               self.label] = str(self.gamma.get_scale())
+        output = super(SAXSISDRestraint, self).get_output()
+        suffix = self._get_label_suffix()
+        output["SAXSISDRestraint_Sigma" +
+               suffix] = str(self.sigma.get_scale())
+        output["SAXSISDRestraint_Tau" + suffix] = str(self.tau.get_scale())
+        output["SAXSISDRestraint_Gamma" +
+               suffix] = str(self.gamma.get_scale())
         return output
+
+    @staticmethod
+    def _logspace(a, b, num=100):
+        """Mimick numpy's logspace function"""
+        for i in range(num):
+            val = a + float(b - a) / float(num - 1) * i
+            yield 10 ** val
diff --git a/modules/pmi/test/expensive_test_replica_exchange.py b/modules/pmi/test/expensive_test_replica_exchange.py
index 14977a3121..2a744bc345 100644
--- a/modules/pmi/test/expensive_test_replica_exchange.py
+++ b/modules/pmi/test/expensive_test_replica_exchange.py
@@ -119,7 +119,7 @@ def test_macro(self):
             self.assertAlmostEqual(avscore, t/2, delta=0.1)
 
         rex_out_file="./test_replica_exchange_macro_output/stat."+str(my_index)+".out"
-        dist_key="DistanceRestraint_None"
+        dist_key="DistanceRestraint_Score"
         mc_nframe_key="MonteCarlo_Nframe"
         mc_temp_key="MonteCarlo_Temperature"
         rex_temp_key="ReplicaExchange_CurrentTemp"
diff --git a/modules/pmi/test/test_parameter_restraints.py b/modules/pmi/test/test_parameter_restraints.py
new file mode 100644
index 0000000000..82abfb4509
--- /dev/null
+++ b/modules/pmi/test/test_parameter_restraints.py
@@ -0,0 +1,44 @@
+from __future__ import print_function, division
+import math
+import IMP
+import IMP.isd
+import IMP.pmi
+import IMP.pmi.restraints.parameters
+import IMP.test
+
+
+class Tests(IMP.test.TestCase):
+
+    def test_weight_restraint(self):
+        m = IMP.Model()
+        weight = IMP.isd.Weight.setup_particle(IMP.Particle(m))
+        weight.add_weight()
+        weight.add_weight()
+        weight.set_weights([.1, .9])
+        lower, upper, kappa = .2, .8, 1.
+        r = IMP.pmi.restraints.parameters.WeightRestraint(weight, lower,
+                                                          upper, kappa)
+        self.assertAlmostEqual(
+            float(r.get_output()["_TotalScore"]), 0.01, delta=1e-6)
+
+        weight.add_weight()
+        weight.set_weights([0., .15, .85])
+        self.assertAlmostEqual(
+            float(r.get_output()["_TotalScore"]), .0225, delta=1e-6)
+
+    def test_jeffreys_prior(self):
+        m = IMP.Model()
+        sigma = IMP.isd.Scale.setup_particle(IMP.Particle(m))
+        sigma.set_scale(1.)
+        r = IMP.pmi.restraints.parameters.JeffreysPrior(sigma)
+
+        self.assertAlmostEqual(
+            float(r.get_output()["_TotalScore"]), 0., delta=1e-6)
+
+        sigma.set_scale(2.)
+        self.assertAlmostEqual(
+            float(r.get_output()["_TotalScore"]), -math.log(.5), delta=1e-6)
+
+
+if __name__ == '__main__':
+    IMP.test.main()
diff --git a/modules/pmi/test/test_restraint_base.py b/modules/pmi/test/test_restraint_base.py
index dcd31f82dc..fcb8fefa35 100644
--- a/modules/pmi/test/test_restraint_base.py
+++ b/modules/pmi/test/test_restraint_base.py
@@ -1,30 +1,35 @@
 from __future__ import print_function, division
+import math
 import IMP
 import IMP.algebra
 import IMP.core
+import IMP.isd
 import IMP.pmi
 import IMP.pmi.restraints
 import IMP.test
 
 
-class Tests(IMP.test.TestCase):
+class DistanceRestraint(IMP.pmi.restraints.RestraintBase):
 
-    def test_functions(self):
+    def __init__(self, p1, p2, d, k, name=None, label=None, weight=1.):
+        m = p1.get_model()
+        super(DistanceRestraint, self).__init__(m, name=name, label=label,
+                                                weight=weight)
+        f = IMP.core.Harmonic(d, k)
+        s = IMP.core.DistancePairScore(f)
+        r = IMP.core.PairRestraint(self.m, s, (p1, p2))
+        self.rs.add_restraint(r)
 
-        class DistanceRestraint(IMP.pmi.restraints.RestraintBase):
-            def __init__(self, p1, p2, d, k):
-                m = p1.get_model()
-                super(DistanceRestraint, self).__init__(m)
-                f = IMP.core.Harmonic(d, k)
-                s = IMP.core.DistancePairScore(f)
-                r = IMP.core.PairRestraint(self.m, s, (p1, p2))
-                self.rs.add_restraint(r)
 
+class Tests(IMP.test.TestCase):
+
+    def test_setup(self):
         m = IMP.Model()
         p1 = IMP.Particle(m)
         IMP.core.XYZ.setup_particle(p1)
         p2 = IMP.Particle(m)
         IMP.core.XYZ.setup_particle(p2)
+
         r = DistanceRestraint(p1, p2, 0., 1.)
         self.assertAlmostEqual(r.evaluate(), 0.0, delta=1e-6)
         output = r.get_output()
@@ -32,14 +37,129 @@ def __init__(self, p1, p2, d, k):
         self.assertEqual(output["_TotalScore"], str(0.0))
         self.assertIsInstance(r.get_restraint_set(), IMP.RestraintSet)
 
+    def test_setup_with_label_weight(self):
+        m = IMP.Model()
+        p1 = IMP.Particle(m)
+        IMP.core.XYZ.setup_particle(p1)
+        p2 = IMP.Particle(m)
+        IMP.core.XYZ.setup_particle(p2)
         IMP.core.XYZ(p2).set_coordinates(IMP.algebra.Vector3D(0, 0, 10))
-        r.set_weight(10.)
-        r.set_label("Test")
+
+        r = DistanceRestraint(p1, p2, 0., 1., name="DistanceRestraint2",
+                              weight=10., label="Test")
         self.assertAlmostEqual(r.evaluate(), 500, delta=1e-6)
         output = r.get_output()
-        self.assertEqual(output["DistanceRestraint_Score_Test"], str(500.0))
+        self.assertEqual(output["DistanceRestraint2_Score_Test"], str(500.0))
         self.assertEqual(output["_TotalScore"], str(500.0))
-        self.assertIsInstance(r.get_restraint_set(), IMP.RestraintSet)
+
+        r.set_weight(1.)
+        output = r.get_output()
+        self.assertEqual(output["DistanceRestraint2_Score_Test"], str(50.0))
+        self.assertEqual(output["_TotalScore"], str(50.0))
+
+    def test_set_label_after_init_raises_error(self):
+        m = IMP.Model()
+        p1 = IMP.Particle(m)
+        IMP.core.XYZ.setup_particle(p1)
+        p2 = IMP.Particle(m)
+        IMP.core.XYZ.setup_particle(p2)
+
+        r = DistanceRestraint(p1, p2, 0., 1., label="Test")
+        with self.assertRaises(ValueError):
+            r.set_label("Test2")
+
+        r = DistanceRestraint(p1, p2, 0., 1.)
+        r.set_label("Test")
+        with self.assertRaises(ValueError):
+            r.set_label("Test2")
+
+        r = DistanceRestraint(p1, p2, 0., 1.)
+        r.get_output()
+        with self.assertRaises(ValueError):
+            r.set_label("Test")
+
+        r = DistanceRestraint(p1, p2, 0., 1.)
+        r.evaluate()
+        with self.assertRaises(ValueError):
+            r.set_label("Test")
+
+        r = DistanceRestraint(p1, p2, 0., 1.)
+        r.add_to_model()
+        with self.assertRaises(ValueError):
+            r.set_label("Test")
+
+        r = DistanceRestraint(p1, p2, 0., 1.)
+        r.get_restraint_set()
+        with self.assertRaises(ValueError):
+            r.set_label("Test")
+
+        r = DistanceRestraint(p1, p2, 0., 1.)
+        r.get_restraint_for_rmf()
+        with self.assertRaises(ValueError):
+            r.set_label("Test")
+
+        r = DistanceRestraint(p1, p2, 0., 1.)
+        r.get_particles_to_sample()
+        with self.assertRaises(ValueError):
+            r.set_label("Test")
+
+    def test_setup_with_nuisance(self):
+
+        class GaussianRestraint(IMP.pmi.restraints._RestraintNuisanceMixin,
+                                IMP.pmi.restraints.RestraintBase):
+
+            def __init__(self, p, mean_val, label=None, weight=1.):
+                m = p.get_model()
+                super(GaussianRestraint, self).__init__(m, label=label,
+                                                        weight=weight)
+
+                self.mu = self._create_nuisance(mean_val, None, None, None,
+                                                "Mu", is_sampled=False)
+                self.sigma = self._create_nuisance(1., 0., None, .1, "Sigma",
+                                                   is_sampled=True)
+
+                r = IMP.isd.GaussianRestraint(p, self.mu, self.sigma)
+                self.rs.add_restraint(r)
+
+                self.rs_jeffreys = self._create_restraint_set(
+                    "Sigma_JeffreysPrior")
+                r = IMP.isd.JeffreysRestraint(self.m, self.sigma)
+                self.rs_jeffreys.add_restraint(r)
+
+        def calculate_gaussian(x, mu, sigma):
+            return -math.log(1. / math.sqrt(2 * math.pi * sigma**2) *
+                             math.exp(-(x - mu)**2 / 2. / sigma**2))
+
+        m = IMP.Model()
+        p = IMP.Particle(m)
+        pnuis = IMP.isd.Nuisance.setup_particle(p)
+        pnuis.set_nuisance(10.)
+
+        r = GaussianRestraint(p, 10., label="Test")
+        self.assertAlmostEqual(r.evaluate(), calculate_gaussian(10., 10., 1.),
+                               delta=1e-6)
+
+        r = GaussianRestraint(p, 11., label="Test")
+        self.assertAlmostEqual(r.evaluate(), calculate_gaussian(11., 10., 1.),
+                               delta=1e-6)
+
+        self.assertEqual(len(r.restraint_sets), 2)
+        self.assertEqual(len(r.get_particles_to_sample()), 1)
+        self.assertIs(r.get_particles_to_sample().values()[0][0][0], r.sigma)
+        self.assertEqual(len(r.get_output()), 5)
+
+        output = r.get_output()
+        self.assertAlmostEqual(
+            float(output["GaussianRestraint_Sigma_JeffreysPrior_Score_Test"]),
+            0., delta=1e-6)
+
+        self.assertFalse(r.mu.get_nuisance_is_optimized())
+        self.assertTrue(r.sigma.get_nuisance_is_optimized())
+        r.sigma.set_nuisance(10.)
+        output = r.get_output()
+        self.assertAlmostEqual(
+            float(output["GaussianRestraint_Sigma_JeffreysPrior_Score_Test"]),
+            -math.log(.1), delta=1e-6)
 
 
 if __name__ == '__main__':