def test_of_correlation_function_addition(self):
        """Testing addition of CorrelationFunction objects """
        
        t = TimeAxis(0.0, 1000, 1.0)
        params1 = dict(ftype="OverdampedBrownian",
                       reorg = 30.0,
                       cortime = 100.0,
                       T = 300.0)
        params2 = dict(ftype="OverdampedBrownian",
                       reorg = 40.0,
                       cortime = 100.0,
                       T = 300.0)
        
        f1 = CorrelationFunction(t, params1)
        f2 = CorrelationFunction(t, params2)
        
        #
        # normal addition
        #
        f = f1 + f2
        sum_data = f1.data + f2.data
        sum_lamb = f1.lamb + f2.lamb
        sum_cutoff = max(f1.cutoff_time, f2.cutoff_time)
        sum_temp = f1.temperature
        
        self.assertEqual(f.lamb, sum_lamb)
        numpy.testing.assert_allclose(f.data, sum_data)
        self.assertEqual(f.cutoff_time, sum_cutoff)
        self.assertEqual(f.temperature, sum_temp)
        
        self.assertFalse(f.is_analytical())
        self.assertTrue(f._is_composed)
        self.assertFalse(f._is_empty)
        
        
        #
        # inplace addition by function
        #
        f1.add_to_data(f2)
        
        self.assertEqual(f1.lamb, sum_lamb)
        numpy.testing.assert_allclose(f1.data, sum_data)       
        self.assertEqual(f1.cutoff_time, sum_cutoff)  
        self.assertEqual(f1.temperature, sum_temp)

        self.assertFalse(f1.is_analytical())
        self.assertTrue(f1._is_composed)
        self.assertFalse(f1._is_empty)
        
        #
        # inplace addition by += operator
        #
        f1 = CorrelationFunction(t, params1) # new object  
        fs = f1
        f1 += f2

        self.assertEqual(f1.lamb, sum_lamb)
        numpy.testing.assert_allclose(f1.data, sum_data)
        self.assertEqual(f1.cutoff_time, sum_cutoff)
        self.assertEqual(f1.temperature, sum_temp)  
        
        self.assertFalse(f1.is_analytical())
        self.assertTrue(f1._is_composed)
        self.assertFalse(f1._is_empty)
        
        # test if inplace addition really happend
        self.assertEqual(fs, f1)
    def test_of_multiple_addition(self):
        """Testing multiple addition of CorrelationFunction objects """
        
        t = TimeAxis(0.0, 1000, 1.0)
        
        params1 = dict(ftype="OverdampedBrownian",
                       reorg = 30.0,
                       cortime = 100.0,
                       T = 300.0)
        params2 = dict(ftype="OverdampedBrownian",
                       reorg = 40.0,
                       cortime = 100.0,
                       T = 300.0)
        params3 = dict(ftype="OverdampedBrownian",
                       reorg = 15.0,
                       cortime = 200.0,
                       T = 300.0)
        params4 = dict(ftype="OverdampedBrownian",
                       reorg = 10.0,
                       cortime = 50.0,
                       T = 300.0)     
        
        f1 = CorrelationFunction(t, params1)
        f2 = CorrelationFunction(t, params2)
        f3 = CorrelationFunction(t, params3)
        f4 = CorrelationFunction(t, params4)
        
        f = f1 + f2 + f3 + f4
        
        sum_data = f1.data + f2.data + f3.data + f4.data
        sum_lamb = f1.lamb + f2.lamb + f3.lamb + f4.lamb
        sum_cutoff = max(f1.cutoff_time, f2.cutoff_time,
                         f3.cutoff_time, f4.cutoff_time)
        sum_temp = f1.temperature        

        self.assertEqual(f.lamb, sum_lamb)
        numpy.testing.assert_allclose(f.data, sum_data)
        self.assertEqual(f.cutoff_time, sum_cutoff)
        self.assertEqual(f.temperature, sum_temp)
        
        self.assertFalse(f.is_analytical())
        self.assertTrue(f._is_composed)
        self.assertFalse(f._is_empty)    
        
        #
        # Inplace
        #  
        
        f1 = CorrelationFunction(t, params1)
        f2 = CorrelationFunction(t, params2)
        f3 = CorrelationFunction(t, params3)
        f4 = CorrelationFunction(t, params4)
        fs = f1
        
        sum_data = f1.data + f2.data + f3.data + f4.data
        sum_lamb = f1.lamb + f2.lamb + f3.lamb + f4.lamb
        sum_cutoff = max(f1.cutoff_time, f2.cutoff_time,
                         f3.cutoff_time, f4.cutoff_time)
        sum_temp = f3.temperature 
        
        f1 += f2 + f3
        f1 += f4
        
        f = f1
        
        self.assertEqual(f.lamb, sum_lamb)
        numpy.testing.assert_allclose(f.data, sum_data)
        self.assertEqual(f.cutoff_time, sum_cutoff)
        self.assertEqual(f.temperature, sum_temp)
        
        self.assertFalse(f.is_analytical())
        self.assertTrue(f._is_composed)
        self.assertFalse(f._is_empty)        

        # test if inplace addition really happend
        self.assertEqual(fs, f1)
        
        #
        # Loops 
        #
        f1 = CorrelationFunction(t, params1)
        f2 = CorrelationFunction(t, params1)
        
        f1_data = f1.data.copy()
        for i in range(5):
            f1 += f1

        self.assertEqual(f1.lamb, 32.0*params1["reorg"])
        numpy.testing.assert_allclose(f1.data, 32.0*f1_data)
        self.assertEqual(f1.temperature, params1["T"])  
        
        self.assertFalse(f1.is_analytical())
        self.assertTrue(f1._is_composed)
        self.assertFalse(f1._is_empty)            
        
        f1 = CorrelationFunction(t, params1)
        for i in range(5):
            f1 += f2

        self.assertEqual(f1.lamb, 6.0*params1["reorg"])
        numpy.testing.assert_allclose(f1.data, 6.0*f1_data)
        self.assertEqual(f1.temperature, params1["T"])  
        
        self.assertFalse(f1.is_analytical())
        self.assertTrue(f1._is_composed)
        self.assertFalse(f1._is_empty)  

        self.assertEqual(f1.params["ftype"],"Value-defined")