Index: Invariant/invariant.py
===================================================================
--- Invariant/invariant.py	(revision c75a8ed10188ecdc61e67bf33da877dab8980eb5)
+++ Invariant/invariant.py	(revision 90e5ca13393fa3e11008a8cec3322becef8bac1e)
@@ -362,8 +362,10 @@
         self._low_extrapolation_function = Guinier()
         self._low_extrapolation_power = None
+        self._low_extrapolation_power_fitted = None
    
         self._high_extrapolation_npts = 4
         self._high_extrapolation_function = PowerLaw()
         self._high_extrapolation_power = None
+        self._high_extrapolation_power_fitted = None
         
         # Extrapolation range
@@ -391,5 +393,5 @@
         return  new_data
      
-    def _fit(self, model, qmin=Q_MINIMUM, qmax=Q_MAXIMUM, power=None):
+    def _fit(self, model, qmin=Q_MINIMUM, qmax=Q_MAXIMUM, power=None, range=None):
         """
             fit data with function using 
@@ -408,4 +410,8 @@
         extrapolator = Extrapolator(data=self._data, model=model)
         p, dp = extrapolator.fit(power=power, qmin=qmin, qmax=qmax) 
+        if range is not None and range == 'low':
+            self._low_extrapolation_power_fitted = -1*p[0]
+        if range is not None and range == 'high':
+            self._high_extrapolation_power_fitted = -1*p[0]
         
         return model.extract_model_parameters(constant=p[1], slope=p[0], dconstant=dp[1], dslope=dp[0])
@@ -511,4 +517,12 @@
         return result_data
     
+    def get_extrapolation_power(self, range='high'):
+        """
+            return the fitted power for power law function at a givenr ange
+        """
+        if range == 'low':
+            return self._low_extrapolation_power_fitted
+        return self._high_extrapolation_power_fitted
+    
     def get_qstar_low(self):
         """
@@ -529,5 +543,6 @@
                          qmin=qmin,
                          qmax=qmax,
-                         power=self._low_extrapolation_power)
+                         power=self._low_extrapolation_power,
+                         range='low')
         
         # Distribution starting point
@@ -566,5 +581,6 @@
                          qmin=qmin,
                          qmax=qmax,
-                         power=self._high_extrapolation_power)
+                         power=self._high_extrapolation_power,
+                         range='high')
         
         #create new Data1D to compute the invariant
@@ -653,4 +669,5 @@
             self._high_extrapolation_npts  = npts
             self._high_extrapolation_power = power
+            self._high_extrapolation_power_fitted = power
         else:
             if function == 'power_law':
@@ -660,4 +677,5 @@
             self._low_extrapolation_npts  = npts
             self._low_extrapolation_power = power
+            self._low_extrapolation_power_fitted = power
         
     def get_qstar(self, extrapolation=None):
Index: Invariant/test/utest_use_cases.py
===================================================================
--- Invariant/test/utest_use_cases.py	(revision bdd162f5349c7a04e2359fd1cf7400d39b0a0998)
+++ Invariant/test/utest_use_cases.py	(revision 90e5ca13393fa3e11008a8cec3322becef8bac1e)
@@ -237,5 +237,30 @@
         self.assertAlmostEquals(s , 941.7452, 3)
       
-  
+    def test_use_case_6(self):
+        """
+            Invariant with high-Q extrapolation
+        """
+        # Create invariant object. Background and scale left as defaults.
+        inv = invariant.InvariantCalculator(data=self.data)
+        
+        # Set the extrapolation parameters for the high-Q range
+        inv.set_extrapolation(range='low', npts=10, function='power_law', power=4)
+        
+        # The version of the call without error
+        # The function parameter defaults to None, then is picked to be 'power_law' for extrapolation='high'
+        qstar = inv.get_qstar(extrapolation='low')
+        
+        # The version of the call with error
+        qstar, qstar_err = inv.get_qstar_with_error(extrapolation='low')
+
+        # Get the volume fraction and surface
+        v, dv = inv.get_volume_fraction_with_error(contrast=2.6e-6)
+        s, ds = inv.get_surface_with_error(contrast=2.6e-6, porod_const=2)
+        
+        # Test results
+        self.assertAlmostEquals(qstar, 7.49e-5,2)
+        self.assertAlmostEquals(v, 0.005952674, 3)
+        self.assertAlmostEquals(s , 941.7452, 3)
+        
 class TestInvPinholeSmear(unittest.TestCase):
     """
