code refactoring and unittest for block container

9 files changed, 586 insertions, 277 deletions

diff --git a/Wrappers/Python/ccpi/framework/BlockDataContainer.py b/Wrappers/Python/ccpi/framework/BlockDataContainer.py
new file mode 100755
index 0000000..9a42a16
--- /dev/null
+++ b/Wrappers/Python/ccpi/framework/BlockDataContainer.py
@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*-

+"""

+Created on Tue Mar  5 16:04:45 2019

+

+@author: ofn77899

+"""

+from __future__ import absolute_import

+from __future__ import division

+from __future__ import print_function

+from __future__ import unicode_literals

+

+import numpy

+from numbers import Number

+import functools

+#from ccpi.framework import AcquisitionData, ImageData

+#from ccpi.optimisation.operators import Operator, LinearOperator

+ 

+class BlockDataContainer(object):

+    '''Class to hold a composite operator'''

+    __array_priority__ = 1

+    def __init__(self, *args, shape=None):

+        '''containers must be passed row by row'''

+        self.containers = args

+        self.index = 0

+        if shape is None:

+            shape = (len(args),1)

+        self.shape = shape

+        n_elements = functools.reduce(lambda x,y: x*y, shape, 1)

+        if len(args) != n_elements:

+            raise ValueError(

+                    'Dimension and size do not match: expected {} got {}'

+                    .format(n_elements,len(args)))

+#        for i in range(shape[0]):

+#            b.append([])

+#            for j in range(shape[1]):

+#                b[-1].append(args[i*shape[1]+j])

+#                indices.append(i*shape[1]+j)

+#        self.containers = b

+        

+    def __iter__(self):

+        return self

+    def next(self):

+        '''python2 backwards compatibility'''

+        return self.__next__()

+    def __next__(self):

+        try:

+            out = self[self.index]

+        except IndexError as ie:

+            raise StopIteration()

+        self.index+=1

+        return out

+    

+    def is_compatible(self, other):

+        '''basic check if the size of the 2 objects fit'''

+        if isinstance(other, Number):

+            return True   

+        elif isinstance(other, list):

+            # TODO look elements should be numbers

+            for ot in other:

+                if not isinstance(ot, (Number,\

+                                 numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.int64,\

+                                 numpy.float, numpy.float16, numpy.float32, numpy.float64, \

+                                 numpy.complex)):

+                    raise ValueError('List/ numpy array can only contain numbers {}'\

+                                     .format(type(ot)))

+            return len(self.containers) == len(other)

+        elif isinstance(other, numpy.ndarray):

+            return self.shape == other.shape

+        return len(self.containers) == len(other.containers)

+    def get_item(self, row, col=0):

+        if row > self.shape[0]:

+            raise ValueError('Requested row {} > max {}'.format(row, self.shape[0]))

+        if col > self.shape[1]:

+            raise ValueError('Requested col {} > max {}'.format(col, self.shape[1]))

+        

+        index = row*self.shape[1]+col

+        return self.containers[index]

+                

+    def add(self, other, out=None, *args, **kwargs):

+        assert self.is_compatible(other)

+        if isinstance(other, Number):

+            return type(self)(*[ el.add(other, out, *args, **kwargs) for el in self.containers])

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            return type(self)(*[ el.add(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])

+        return type(self)(*[ el.add(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])

+        

+    def subtract(self, other, out=None , *args, **kwargs):

+        assert self.is_compatible(other)

+        if isinstance(other, Number):

+            return type(self)(*[ el.subtract(other, out, *args, **kwargs) for el in self.containers])

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            return type(self)(*[ el.subtract(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])

+        return type(self)(*[ el.subtract(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])

+

+    def multiply(self, other , out=None, *args, **kwargs):

+        self.is_compatible(other)

+        if isinstance(other, Number):

+            return type(self)(*[ el.multiply(other, out, *args, **kwargs) for el in self.containers])

+        elif isinstance(other, list):

+            return type(self)(*[ el.multiply(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])

+        elif isinstance(other, numpy.ndarray):           

+            return type(self)(*[ el.multiply(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])

+        return type(self)(*[ el.multiply(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])

+    

+    def divide(self, other , out=None ,*args, **kwargs):

+        self.is_compatible(other)

+        if isinstance(other, Number):

+            return type(self)(*[ el.divide(other, out, *args, **kwargs) for el in self.containers])

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            return type(self)(*[ el.divide(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])

+        return type(self)(*[ el.divide(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])

+    

+    def power(self, other , out=None, *args, **kwargs):

+        assert self.is_compatible(other)

+        if isinstance(other, Number):

+            return type(self)(*[ el.power(other, out, *args, **kwargs) for el in self.containers])

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            return type(self)(*[ el.power(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])

+        return type(self)(*[ el.power(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])

+    

+    def maximum(self,other, out=None, *args, **kwargs):

+        assert self.is_compatible(other)

+        if isinstance(other, Number):

+            return type(self)(*[ el.maximum(other, out, *args, **kwargs) for el in self.containers])

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            return type(self)(*[ el.maximum(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])

+        return type(self)(*[ el.maximum(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])

+    

+    ## unary operations    

+    def abs(self, out=None, *args,  **kwargs):

+        return type(self)(*[ el.abs(out, *args, **kwargs) for el in self.containers]) 

+    def sign(self, out=None, *args,  **kwargs):

+        return type(self)(*[ el.sign(out, *args, **kwargs) for el in self.containers])

+    def sqrt(self, out=None, *args,  **kwargs):

+        return type(self)(*[ el.sqrt(out, *args, **kwargs) for el in self.containers])

+    def conjugate(self, out=None):

+        return type(self)(*[el.conjugate() for el in self.containers])

+    

+    ## reductions

+    def sum(self, out=None, *args, **kwargs):

+        return numpy.asarray([ el.sum(*args, **kwargs) for el in self.containers])

+    def squared_norm(self):

+        y = numpy.asarray([el.squared_norm() for el in self.containers])

+        return y.sum() 

+    def norm(self):

+        y = numpy.asarray([el.norm() for el in self.containers])

+        return y.sum()    

+    def copy(self):

+        '''alias of clone'''    

+        return self.clone()

+    def clone(self):

+        return type(self)(*[el.copy() for el in self.containers])

+    

+    def __add__(self, other):

+        return self.add( other )

+    # __radd__

+    

+    def __sub__(self, other):

+        return self.subtract( other )

+    # __rsub__

+    

+    def __mul__(self, other):

+        return self.multiply(other)

+    # __rmul__

+    

+    def __div__(self, other):

+        return self.divide(other)

+    # __rdiv__

+    def __truediv__(self, other):

+        return self.divide(other)

+    

+    def __pow__(self, other):

+        return self.power(other)

+    # reverse operand

+    def __radd__(self, other):

+        '''Reverse addition

+        

+        to make sure that this method is called rather than the __mul__ of a numpy array

+        the class constant __array_priority__ must be set > 0

+        https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.classes.html#numpy.class.__array_priority__

+        '''

+        return self + other

+    # __radd__

+    

+    def __rsub__(self, other):

+        '''Reverse subtraction

+        

+        to make sure that this method is called rather than the __mul__ of a numpy array

+        the class constant __array_priority__ must be set > 0

+        https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.classes.html#numpy.class.__array_priority__

+        '''

+        return (-1 * self) + other

+    # __rsub__

+    

+    def __rmul__(self, other):

+        '''Reverse multiplication

+        

+        to make sure that this method is called rather than the __mul__ of a numpy array

+        the class constant __array_priority__ must be set > 0

+        https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.classes.html#numpy.class.__array_priority__

+        '''

+        return self * other

+    # __rmul__

+    

+    def __rdiv__(self, other):

+        '''Reverse division

+        

+        to make sure that this method is called rather than the __mul__ of a numpy array

+        the class constant __array_priority__ must be set > 0

+        https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.classes.html#numpy.class.__array_priority__

+        '''

+        return pow(self / other, -1)

+    # __rdiv__

+    def __rtruediv__(self, other):

+        '''Reverse truedivision

+        

+        to make sure that this method is called rather than the __mul__ of a numpy array

+        the class constant __array_priority__ must be set > 0

+        https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.classes.html#numpy.class.__array_priority__

+        '''

+        return self.__rdiv__(other)

+    

+    def __rpow__(self, other):

+        '''Reverse power

+        

+        to make sure that this method is called rather than the __mul__ of a numpy array

+        the class constant __array_priority__ must be set > 0

+        https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.classes.html#numpy.class.__array_priority__

+        '''

+        return other.power(self)

+    

+    def __iadd__(self, other):

+        '''Inline addition'''

+        if isinstance (other, BlockDataContainer):

+            for el,ot in zip(self.containers, other.containers):

+                el += ot

+        elif isinstance(other, Number):

+            for el in self.containers:

+                el += other

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            self.is_compatible(other)

+            for el,ot in zip(self.containers, other):

+                el += ot

+        return self

+    # __iadd__

+    

+    def __isub__(self, other):

+        '''Inline subtraction'''

+        if isinstance (other, BlockDataContainer):

+            for el,ot in zip(self.containers, other.containers):

+                el -= ot

+        elif isinstance(other, Number):

+            for el in self.containers:

+                el -= other

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            assert self.is_compatible(other)

+            for el,ot in zip(self.containers, other):

+                el -= ot

+        return self

+    # __isub__

+    

+    def __imul__(self, other):

+        '''Inline multiplication'''

+        if isinstance (other, BlockDataContainer):

+            for el,ot in zip(self.containers, other.containers):

+                el *= ot

+        elif isinstance(other, Number):

+            for el in self.containers:

+                el *= other

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            assert self.is_compatible(other)

+            for el,ot in zip(self.containers, other):

+                el *= ot

+        return self

+    # __imul__

+    

+    def __idiv__(self, other):

+        '''Inline division'''

+        if isinstance (other, BlockDataContainer):

+            for el,ot in zip(self.containers, other.containers):

+                el /= ot

+        elif isinstance(other, Number):

+            for el in self.containers:

+                el /= other

+        elif isinstance(other, list) or isinstance(other, numpy.ndarray):

+            assert self.is_compatible(other)

+            for el,ot in zip(self.containers, other):

+                el /= ot

+        return self

+    # __rdiv__

+    def __itruediv__(self, other):

+        '''Inline truedivision'''

+        return self.__idiv__(other)

+    
\ No newline at end of file
diff --git a/Wrappers/Python/ccpi/framework/__init__.py b/Wrappers/Python/ccpi/framework/__init__.py
new file mode 100755
index 0000000..083f547
--- /dev/null
+++ b/Wrappers/Python/ccpi/framework/__init__.py
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-

+"""

+Created on Tue Mar  5 16:00:18 2019

+

+@author: ofn77899

+"""

+from __future__ import absolute_import

+from __future__ import division

+from __future__ import print_function

+from __future__ import unicode_literals

+

+import numpy

+import sys

+from datetime import timedelta, datetime

+import warnings

+from functools import reduce

+

+from .framework import DataContainer

+from .framework import ImageData, AcquisitionData

+from .framework import ImageGeometry, AcquisitionGeometry

+from .framework import find_key, message

+from .framework import DataProcessor

+from .framework import AX, PixelByPixelDataProcessor

+from .BlockDataContainer import BlockDataContainer

diff --git a/Wrappers/Python/ccpi/framework.py b/Wrappers/Python/ccpi/framework/framework.py
index dab2dd9..dab2dd9 100644..100755
--- a/Wrappers/Python/ccpi/framework.py
+++ b/Wrappers/Python/ccpi/framework/framework.py
diff --git a/Wrappers/Python/ccpi/optimisation/operators/BlockOperator.py b/Wrappers/Python/ccpi/optimisation/operators/BlockOperator.py
index b8285b0..145277f 100755
--- a/Wrappers/Python/ccpi/optimisation/operators/BlockOperator.py
+++ b/Wrappers/Python/ccpi/optimisation/operators/BlockOperator.py
@@ -8,283 +8,9 @@ Created on Thu Feb 14 12:36:40 2019
 import numpy
 from numbers import Number
 import functools
-from ccpi.framework import AcquisitionData, ImageData
+from ccpi.framework import AcquisitionData, ImageData, BlockDataContainer
+from ccpi.optimisation.operators import Operator, LinearOperator
 
-class Operator(object):
-    '''Operator that maps from a space X -> Y'''
-    def __init__(self, **kwargs):
-        self.scalar = 1
-    def is_linear(self):
-        '''Returns if the operator is linear'''
-        return False
-    def direct(self,x, out=None):
-        raise NotImplementedError
-    def size(self):
-        # To be defined for specific class
-        raise NotImplementedError
-    def norm(self):
-        raise NotImplementedError
-    def range_dim(self):
-        raise NotImplementedError
-    def domain_dim(self):
-        raise NotImplementedError
-    def __rmul__(self, other):
-        assert isinstance(other, Number)
-        self.scalar = other
-        return self
-
-class LinearOperator(Operator):
-    '''Operator that maps from a space X -> Y'''
-    def is_linear(self):
-        '''Returns if the operator is linear'''
-        return True
-    def adjoint(self,x, out=None):
-        raise NotImplementedError
-
-# this should go in the framework
-        
-class BlockDataContainer(object):
-    '''Class to hold a composite operator'''
-    __array_priority__ = 1
-    def __init__(self, *args, shape=None):
-        '''containers must be passed row by row'''
-        self.containers = args
-        self.index = 0
-        if shape is None:
-            shape = (len(args),1)
-        self.shape = shape
-        n_elements = functools.reduce(lambda x,y: x*y, shape, 1)
-        if len(args) != n_elements:
-            raise ValueError(
-                    'Dimension and size do not match: expected {} got {}'
-                    .format(n_elements,len(args)))
-#        for i in range(shape[0]):
-#            b.append([])
-#            for j in range(shape[1]):
-#                b[-1].append(args[i*shape[1]+j])
-#                indices.append(i*shape[1]+j)
-#        self.containers = b
-        
-    def __iter__(self):
-        return self
-    def next(self):
-        '''python2 backwards compatibility'''
-        return self.__next__()
-    def __next__(self):
-        try:
-            out = self[self.index]
-        except IndexError as ie:
-            raise StopIteration()
-        self.index+=1
-        return out
-    
-    def is_compatible(self, other):
-        '''basic check if the size of the 2 objects fit'''
-        if isinstance(other, Number):
-            return True   
-        elif isinstance(other, list):
-            # TODO look elements should be numbers
-            for ot in other:
-                if not isinstance(ot, (Number,\
-                                 numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.int64,\
-                                 numpy.float, numpy.float16, numpy.float32, numpy.float64, \
-                                 numpy.complex)):
-                    raise ValueError('List/ numpy array can only contain numbers {}'\
-                                     .format(type(ot)))
-            return len(self.containers) == len(other)
-        elif isinstance(other, numpy.ndarray):
-            return self.shape == other.shape
-        return len(self.containers) == len(other.containers)
-    def get_item(self, row, col=0):
-        if row > self.shape[0]:
-            raise ValueError('Requested row {} > max {}'.format(row, self.shape[0]))
-        if col > self.shape[1]:
-            raise ValueError('Requested col {} > max {}'.format(col, self.shape[1]))
-        
-        index = row*self.shape[1]+col
-        return self.containers[index]
-                
-    def add(self, other, out=None, *args, **kwargs):
-        assert self.is_compatible(other)
-        if isinstance(other, Number):
-            return type(self)(*[ el.add(other, out, *args, **kwargs) for el in self.containers])
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            return type(self)(*[ el.add(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])
-        return type(self)(*[ el.add(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])
-        
-    def subtract(self, other, out=None , *args, **kwargs):
-        assert self.is_compatible(other)
-        if isinstance(other, Number):
-            return type(self)(*[ el.subtract(other, out, *args, **kwargs) for el in self.containers])
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            return type(self)(*[ el.subtract(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])
-        return type(self)(*[ el.subtract(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])
-
-    def multiply(self, other , out=None, *args, **kwargs):
-        self.is_compatible(other)
-        if isinstance(other, Number):
-            return type(self)(*[ el.multiply(other, out, *args, **kwargs) for el in self.containers])
-        elif isinstance(other, list):
-            return type(self)(*[ el.multiply(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])
-        elif isinstance(other, numpy.ndarray):           
-            return type(self)(*[ el.multiply(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])
-        return type(self)(*[ el.multiply(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])
-    
-    def divide(self, other , out=None ,*args, **kwargs):
-        self.is_compatible(other)
-        if isinstance(other, Number):
-            return type(self)(*[ el.divide(other, out, *args, **kwargs) for el in self.containers])
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            return type(self)(*[ el.divide(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])
-        return type(self)(*[ el.divide(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])
-    
-    def power(self, other , out=None, *args, **kwargs):
-        assert self.is_compatible(other)
-        if isinstance(other, Number):
-            return type(self)(*[ el.power(other, out, *args, **kwargs) for el in self.containers])
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            return type(self)(*[ el.power(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])
-        return type(self)(*[ el.power(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])
-    
-    def maximum(self,other, out=None, *args, **kwargs):
-        assert self.is_compatible(other)
-        if isinstance(other, Number):
-            return type(self)(*[ el.maximum(other, out, *args, **kwargs) for el in self.containers])
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            return type(self)(*[ el.maximum(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other)])
-        return type(self)(*[ el.maximum(ot, out, *args, **kwargs) for el,ot in zip(self.containers,other.containers)])
-    
-    ## unary operations    
-    def abs(self, out=None, *args,  **kwargs):
-        return type(self)(*[ el.abs(out, *args, **kwargs) for el in self.containers]) 
-    def sign(self, out=None, *args,  **kwargs):
-        return type(self)(*[ el.sign(out, *args, **kwargs) for el in self.containers])
-    def sqrt(self, out=None, *args,  **kwargs):
-        return type(self)(*[ el.sqrt(out, *args, **kwargs) for el in self.containers])
-    def conjugate(self, out=None):
-        return type(self)(*[el.conjugate() for el in self.containers])
-    
-    ## reductions
-    def sum(self, out=None, *args, **kwargs):
-        return numpy.asarray([ el.sum(*args, **kwargs) for el in self.containers])
-    def squared_norm(self):
-        y = numpy.asarray([el.squared_norm() for el in self.containers])
-        return y.sum() 
-    def norm(self):
-        y = numpy.asarray([el.norm() for el in self.containers])
-        return y.sum()    
-    def copy(self):
-        '''alias of clone'''    
-        return self.clone()
-    def clone(self):
-        return type(self)(*[el.copy() for el in self.containers])
-    
-    def __add__(self, other):
-        return self.add( other )
-    # __radd__
-    
-    def __sub__(self, other):
-        return self.subtract( other )
-    # __rsub__
-    
-    def __mul__(self, other):
-        return self.multiply(other)
-    # __rmul__
-    
-    def __div__(self, other):
-        return self.divide(other)
-    # __rdiv__
-    def __truediv__(self, other):
-        return self.divide(other)
-    
-    def __pow__(self, other):
-        return self.power(other)
-    # reverse operand
-    def __radd__(self, other):
-        return self + other
-    # __radd__
-    
-    def __rsub__(self, other):
-        return (-1 * self) + other
-    # __rsub__
-    
-    def __rmul__(self, other):
-        '''Reverse multiplication
-        
-        to make sure that this method is called rather than the __mul__ of a numpy array
-        the class constant __array_priority__ must be set > 0
-        https://docs.scipy.org/doc/numpy-1.15.1/reference/arrays.classes.html#numpy.class.__array_priority__
-        '''
-        return self * other
-    # __rmul__
-    
-    def __rdiv__(self, other):
-        return pow(self / other, -1)
-    # __rdiv__
-    def __rtruediv__(self, other):
-        return self.__rdiv__(other)
-    
-    def __rpow__(self, other):
-        return other.power(self)
-    
-    def __iadd__(self, other):
-        if isinstance (other, BlockDataContainer):
-            for el,ot in zip(self.containers, other.containers):
-                el += ot
-        elif isinstance(other, Number):
-            for el in self.containers:
-                el += other
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            self.is_compatible(other)
-            for el,ot in zip(self.containers, other):
-                el += ot
-        return self
-    # __radd__
-    
-    def __isub__(self, other):
-        if isinstance (other, BlockDataContainer):
-            for el,ot in zip(self.containers, other.containers):
-                el -= ot
-        elif isinstance(other, Number):
-            for el in self.containers:
-                el -= other
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            assert self.is_compatible(other)
-            for el,ot in zip(self.containers, other):
-                el -= ot
-        return self
-    # __rsub__
-    
-    def __imul__(self, other):
-        if isinstance (other, BlockDataContainer):
-            for el,ot in zip(self.containers, other.containers):
-                el *= ot
-        elif isinstance(other, Number):
-            for el in self.containers:
-                el *= other
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            assert self.is_compatible(other)
-            for el,ot in zip(self.containers, other):
-                el *= ot
-        return self
-    # __imul__
-    
-    def __idiv__(self, other):
-        if isinstance (other, BlockDataContainer):
-            for el,ot in zip(self.containers, other.containers):
-                el /= ot
-        elif isinstance(other, Number):
-            for el in self.containers:
-                el /= other
-        elif isinstance(other, list) or isinstance(other, numpy.ndarray):
-            assert self.is_compatible(other)
-            for el,ot in zip(self.containers, other):
-                el /= ot
-        return self
-    # __rdiv__
-    def __itruediv__(self, other):
-        return self.__idiv__(other)
-    
 
        
 class BlockOperator(Operator):
diff --git a/Wrappers/Python/ccpi/optimisation/operators/LinearOperator.py b/Wrappers/Python/ccpi/optimisation/operators/LinearOperator.py
new file mode 100755
index 0000000..d0e7804
--- /dev/null
+++ b/Wrappers/Python/ccpi/optimisation/operators/LinearOperator.py
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-

+"""

+Created on Tue Mar  5 15:57:52 2019

+

+@author: ofn77899

+"""

+

+from ccpi.optimisation.operators import Operator

+

+class LinearOperator(Operator):

+    '''Operator that maps from a space X -> Y'''

+    def is_linear(self):

+        '''Returns if the operator is linear'''

+        return True

+    def adjoint(self,x, out=None):

+        '''returns the adjoint/inverse operation

+        

+        only available to linear operators'''

+        raise NotImplementedError

diff --git a/Wrappers/Python/ccpi/optimisation/operators/Operator.py b/Wrappers/Python/ccpi/optimisation/operators/Operator.py
new file mode 100755
index 0000000..ea08b30
--- /dev/null
+++ b/Wrappers/Python/ccpi/optimisation/operators/Operator.py
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-

+"""

+Created on Tue Mar  5 15:55:56 2019

+

+@author: ofn77899

+"""

+

+class Operator(object):

+    '''Operator that maps from a space X -> Y'''

+    def __init__(self, **kwargs):

+        self.scalar = 1

+    def is_linear(self):

+        '''Returns if the operator is linear'''

+        return False

+    def direct(self,x, out=None):

+        raise NotImplementedError

+    def size(self):

+        # To be defined for specific class

+        raise NotImplementedError

+    def norm(self):

+        raise NotImplementedError

+    def range_geometry(self):

+        raise NotImplementedError

+    def domain_geometry(self):

+        raise NotImplementedError

diff --git a/Wrappers/Python/ccpi/optimisation/operators/__init__.py b/Wrappers/Python/ccpi/optimisation/operators/__init__.py
new file mode 100755
index 0000000..088f48c
--- /dev/null
+++ b/Wrappers/Python/ccpi/optimisation/operators/__init__.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-

+"""

+Created on Tue Mar  5 15:56:27 2019

+

+@author: ofn77899

+"""

+

+from .Operator import Operator

+from .LinearOperator import LinearOperator

+from .BlockOperator import BlockOperator

diff --git a/Wrappers/Python/setup.py b/Wrappers/Python/setup.py
index 7a55764..630e33e 100644
--- a/Wrappers/Python/setup.py
+++ b/Wrappers/Python/setup.py
@@ -31,7 +31,8 @@ if  cil_version == '':
 setup(
     name="ccpi-framework",
     version=cil_version,
-    packages=['ccpi' , 'ccpi.io', 'ccpi.optimisation', 
+    packages=['ccpi' , 'ccpi.io', 
+              'ccpi.framework', 'ccpi.optimisation', 
               'ccpi.optimisation.operators',
               'ccpi.optimisation.algorithms'],
 
diff --git a/Wrappers/Python/test/test_BlockDataContainer.py b/Wrappers/Python/test/test_BlockDataContainer.py
new file mode 100755
index 0000000..824abf6
--- /dev/null
+++ b/Wrappers/Python/test/test_BlockDataContainer.py
@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-

+"""

+Created on Tue Mar  5 16:08:23 2019

+

+@author: ofn77899

+"""

+

+import unittest

+import numpy

+#from ccpi.plugins.ops import CCPiProjectorSimple

+from ccpi.optimisation.ops import PowerMethodNonsquare

+from ccpi.optimisation.ops import TomoIdentity

+from ccpi.optimisation.funcs import Norm2sq, Norm1

+from ccpi.framework import ImageGeometry, AcquisitionGeometry

+from ccpi.framework import ImageData, AcquisitionData

+#from ccpi.optimisation.algorithms import GradientDescent

+from ccpi.framework import BlockDataContainer

+#from ccpi.optimisation.Algorithms import CGLS

+

+class TestBlockDataContainer(unittest.TestCase):

+    def test_BlockDataContainer(self):

+        print ("test block data container")

+        ig0 = ImageGeometry(2,3,4)

+        ig1 = ImageGeometry(12,42,55,32)

+        

+        data0 = ImageData(geometry=ig0)

+        data1 = ImageData(geometry=ig1) + 1

+        

+        data2 = ImageData(geometry=ig0) + 2

+        data3 = ImageData(geometry=ig1) + 3

+        

+        cp0 = BlockDataContainer(data0,data1)

+        cp1 = BlockDataContainer(data2,data3)

+    #    

+        a = [ (el, ot) for el,ot in zip(cp0.containers,cp1.containers)]

+        print  (a[0][0].shape)

+        #cp2 = BlockDataContainer(*a)

+        cp2 = cp0.add(cp1)

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 2.)

+        assert (cp2.get_item(1,0).as_array()[0][0][0] == 4.)

+        

+        cp2 = cp0 + cp1 

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 2.)

+        assert (cp2.get_item(1,0).as_array()[0][0][0] == 4.)

+        cp2 = cp0 + 1 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 1. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2., decimal = 5)

+        cp2 = cp0 + [1 ,2]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 1. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 3., decimal = 5)

+        cp2 += cp1

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , +3. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , +6., decimal = 5)

+        

+        cp2 += 1

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , +4. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , +7., decimal = 5)

+        

+        cp2 += [-2,-1]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 2. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 6., decimal = 5)

+        

+        

+        cp2 = cp0.subtract(cp1)

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == -2.)

+        assert (cp2.get_item(1,0).as_array()[0][0][0] == -2.)

+        cp2 = cp0 - cp1

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == -2.)

+        assert (cp2.get_item(1,0).as_array()[0][0][0] == -2.)

+        

+        cp2 = cp0 - 1 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , -1. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 0, decimal = 5)

+        cp2 = cp0 - [1 ,2]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , -1. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , -1., decimal = 5)

+        

+        cp2 -= cp1

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , -3. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , -4., decimal = 5)

+        

+        cp2 -= 1

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , -4. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , -5., decimal = 5)

+        

+        cp2 -= [-2,-1]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , -2. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , -4., decimal = 5)

+        

+        

+        cp2 = cp0.multiply(cp1)

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 0.)

+        assert (cp2.get_item(1,0).as_array()[0][0][0] == 3.)

+        cp2 = cp0 * cp1

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 0.)

+        assert (cp2.get_item(1,0).as_array()[0][0][0] == 3.)

+        

+        cp2 = cp0 * 2 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2, decimal = 5)

+        cp2 = 2 * cp0  

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2, decimal = 5)

+        cp2 = cp0 * [3 ,2]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2., decimal = 5)

+        cp2 = cp0 * numpy.asarray([3 ,2])

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2., decimal = 5)

+        

+        cp2 = [3,2] * cp0 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2., decimal = 5)

+        cp2 = numpy.asarray([3,2]) * cp0 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2., decimal = 5)

+        cp2 = [3,2,3] * cp0 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 2., decimal = 5)

+        

+        cp2 *= cp1

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0 , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , +6., decimal = 5)

+        

+        cp2 *= 1

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , +6., decimal = 5)

+        

+        cp2 *= [-2,-1]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , -6., decimal = 5)

+        

+        

+        cp2 = cp0.divide(cp1)

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 0.)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0], 1./3., decimal=4)

+        cp2 = cp0/cp1

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 0.)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0], 1./3., decimal=4)

+        

+        cp2 = cp0 / 2 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 0.5, decimal = 5)

+        cp2 = cp0 / [3 ,2]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 0.5, decimal = 5)

+        cp2 = cp0 / numpy.asarray([3 ,2])

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 0.5, decimal = 5)

+        cp3 = numpy.asarray([3 ,2]) / (cp0+1)

+        numpy.testing.assert_almost_equal(cp3.get_item(0,0).as_array()[0][0][0] , 3. , decimal=5)

+        numpy.testing.assert_almost_equal(cp3.get_item(1,0).as_array()[0][0][0] , 1, decimal = 5)

+        

+        cp2 += 1

+        cp2 /= cp1

+        # TODO fix inplace division

+         

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 1./2 , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 1.5/3., decimal = 5)

+        

+        cp2 /= 1

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0.5 , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 0.5, decimal = 5)

+        

+        cp2 /= [-2,-1]

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , -0.5/2. , decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , -0.5, decimal = 5)

+        ####

+        

+        cp2 = cp0.power(cp1)

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 0.)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0], 1., decimal=4)

+        cp2 = cp0**cp1

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == 0.)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0], 1., decimal=4)

+        

+        cp2 = cp0 ** 2 

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0] , 0., decimal=5)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0] , 1., decimal = 5)

+        

+        cp2 = cp0.maximum(cp1)

+        assert (cp2.get_item(0,0).as_array()[0][0][0] == cp1.get_item(0,0).as_array()[0][0][0])

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0], cp2.get_item(1,0).as_array()[0][0][0], decimal=4)

+        

+        

+        cp2 = cp0.abs()

+        numpy.testing.assert_almost_equal(cp2.get_item(0,0).as_array()[0][0][0], 0., decimal=4)

+        numpy.testing.assert_almost_equal(cp2.get_item(1,0).as_array()[0][0][0], 1., decimal=4)

+        

+        cp2 = cp0.subtract(cp1)

+        s = cp2.sign()

+        numpy.testing.assert_almost_equal(s.get_item(0,0).as_array()[0][0][0], -1., decimal=4)

+        numpy.testing.assert_almost_equal(s.get_item(1,0).as_array()[0][0][0], -1., decimal=4)

+        

+        cp2 = cp0.add(cp1)

+        s = cp2.sqrt()

+        numpy.testing.assert_almost_equal(s.get_item(0,0).as_array()[0][0][0], numpy.sqrt(2), decimal=4)

+        numpy.testing.assert_almost_equal(s.get_item(1,0).as_array()[0][0][0], numpy.sqrt(4), decimal=4)

+        

+        s = cp0.sum()

+        numpy.testing.assert_almost_equal(s[0], 0, decimal=4)

+        s0 = 1

+        s1 = 1

+        for i in cp0.get_item(0,0).shape:

+            s0 *= i

+        for i in cp0.get_item(1,0).shape:

+            s1 *= i

+            

+        numpy.testing.assert_almost_equal(s[1], cp0.get_item(0,0).as_array()[0][0][0]*s0 +cp0.get_item(1,0).as_array()[0][0][0]*s1, decimal=4)

+    
\ No newline at end of file